Introduce basic error handling in FetchDayAsync()

1 files changed, 70 insertions, 41 deletions

diff --git a/BartService.cs b/BartService.cs
index f453423..3238e09 100644
--- a/BartService.cs
+++ b/BartService.cs
@@ -83,7 +83,7 @@ namespace PagerParser.Bart {
         private ILogger          logger;
         private IServiceProvider serviceProvider;
 
-        private string? loginToken;
+        private string loginToken;
 
         private HttpClient httpClient;
 
@@ -97,13 +97,15 @@ namespace PagerParser.Bart {
             this.serviceProvider = serviceProvider;
         }
 
-        public async Task FetchAsync(DateTime fetchUntil) {
+        public async Task FetchDayAsync(DateOnly day) {
             using var scope = serviceProvider.CreateScope();
             using var db    = scope.ServiceProvider.GetRequiredService<PagerContext>();
 
+            logger.LogDebug($"Fetching BART availability status for {day}");
+
             // Prepare API request
             var request = new BartAvailabilityRequest() {
-                RelatedDay                 = DateTime.Now.ToString("yyyy-MM-dd"),
+                RelatedDay                 = day.ToString("yyyy-MM-dd"),
                 LoginToken                 = loginToken,
                 PermissionLevel            = 2,
                 UserQualFilterIds          = [],
@@ -113,15 +115,27 @@ namespace PagerParser.Bart {
             };
 
             // Fetch the data
-            var response = await httpClient.PostAsJsonAsync(
+            HttpResponseMessage response;
+            try {
+                response = await httpClient.PostAsJsonAsync(
                 AvailabilityEndpointUrl,
                 request,
                 new JsonSerializerOptions() {
                     PropertyNamingPolicy = null
                 });
+            } catch(Exception e) {
+                logger.LogError(e, "Error fetching availability status from BART");
+                return;
+            }
 
-            var responseData = await response.Content
-                .ReadFromJsonAsync<BartAvailabilityResponse>();
+            BartAvailabilityResponse responseData;
+            try {
+                responseData = (await response.Content
+                    .ReadFromJsonAsync<BartAvailabilityResponse>())!;
+            } catch(Exception e) {
+                logger.LogError(e, "Error parsing BART JSON response");
+                return;
+            }
 
             // Parse out a list of users from the response
             var users = responseData.GetUserAvailabilityListResult.List
@@ -136,62 +150,77 @@ namespace PagerParser.Bart {
                 .ToArray();
             
             // Add new users to the DB and update the names of existing ones
-            foreach(var user in users) {
-                if(existingUsers.Contains(user.BartMemberId))
-                    db.Update(user);
-                else
-                    db.Add(user);
+            try {
+                foreach(var user in users) {
+                    if(existingUsers.Contains(user.BartMemberId))
+                        db.Update(user);
+                    else
+                        db.Add(user);
+                }
+                await db.SaveChangesAsync();
+            } catch(Exception e) {
+                logger.LogError(e, "Error saving BART members to the DB");
+                return;
             }
 
-            await db.SaveChangesAsync();
-
             LinkedList<BartAvailabilityRecord> availabilityRecords = new();
 
             foreach(var entry in responseData.GetUserAvailabilityListResult.List) {
-                for(int hour = 0; hour < 24; hour++) {
-                    var timestamp = new DateTime(
-                        DateOnly.FromDateTime(entry.RelatedDay),
-                        new TimeOnly(hour, 0),
-                        DateTimeKind.Local);
+                try {
+                    for(int hour = 0; hour < 24; hour++) {
+                        var timestamp = new DateTime(
+                            DateOnly.FromDateTime(entry.RelatedDay),
+                            new TimeOnly(hour, 0),
+                            DateTimeKind.Local);
 
-                    var status = (BartStatus) entry.GetType()
-                        .GetProperty($"Block{hour + 1}")!
-                        .GetValue(entry)!;
+                        var status = (BartStatus) entry.GetType()
+                            .GetProperty($"Block{hour + 1}")!
+                            .GetValue(entry)!;
 
-                    var record = new BartAvailabilityRecord() {
-                        Timestamp  = timestamp.ToUniversalTime(),
-                        Member     = users.First(u => u.BartMemberId == entry.UserId),
-                        Status     = status,
-                        IsDefault  = entry.AvailabilityId < 0,
-                        ModifiedOn = entry.ModifiedOn,
-                        ModifiedBy = users.FirstOrDefault(u => u.MemberName == entry.ModifiedBy),
-                        CreatedBy  = users.FirstOrDefault(u => u.MemberName == entry.CreatedBy)
-                    };
+                        var record = new BartAvailabilityRecord() {
+                            Timestamp  = timestamp.ToUniversalTime(),
+                            Member     = users.First(u => u.BartMemberId == entry.UserId),
+                            Status     = status,
+                            IsDefault  = entry.AvailabilityId < 0,
+                            ModifiedOn = entry.ModifiedOn,
+                            ModifiedBy = users.FirstOrDefault(u => u.MemberName == entry.ModifiedBy),
+                            CreatedBy  = users.FirstOrDefault(u => u.MemberName == entry.CreatedBy)
+                        };
 
-                    // Optionally set the create/modify time if one is present in the fetched record
-                    if(entry.ModifiedOn is not null)
-                        record.ModifiedOn =
-                            DateTime.SpecifyKind((DateTime) entry.ModifiedOn, DateTimeKind.Utc);
-                    if(entry.CreatedOn is not null)
-                        record.CreatedOn =
-                            DateTime.SpecifyKind((DateTime) entry.CreatedOn, DateTimeKind.Utc);
+                        // Optionally set the create/modify time if
+                        // one is present in the fetched record
+                        if(entry.ModifiedOn is not null)
+                            record.ModifiedOn =
+                                DateTime.SpecifyKind((DateTime) entry.ModifiedOn, DateTimeKind.Utc);
+                        if(entry.CreatedOn is not null)
+                            record.CreatedOn =
+                                DateTime.SpecifyKind((DateTime) entry.CreatedOn, DateTimeKind.Utc);
 
-                    availabilityRecords.AddLast(record);
+                        availabilityRecords.AddLast(record);
+                    }
+                } catch(Exception e) {
+                    logger.LogError(e, "Unknown error occurred whilst parsing availability entries");
+                    return;
                 }
             }
 
             var toAdd = availabilityRecords
                 .ExceptBy(db.BartAvailabilityRecords.Select(e => e.Hashcode), e => e.Hashcode);
 
-            await db.BartAvailabilityRecords.AddRangeAsync(toAdd);
-            await db.SaveChangesAsync();
+            try {
+                await db.BartAvailabilityRecords.AddRangeAsync(toAdd);
+                await db.SaveChangesAsync();
+            } catch(Exception e) {
+                logger.LogError(e, "Error committing availability entries to the DB");
+                return;
+            }
         }
 
         public async Task StartAsync(CancellationToken cancellationToken) {
             logger.LogInformation("BART service starting...");
             loginToken = config.GetValue<string>("PagerParser:Bart:Token");
             httpClient = new();
-            await FetchAsync(DateTime.Now);
+            await FetchDayAsync(DateOnly.FromDateTime(DateTime.Now));
         }
 
         public Task StopAsync(CancellationToken cancellationToken) {