Updated controller to refresh in another task

src/Backend/Controllers/ProblemsController.cs

@@ -18,6 +18,13 @@ public ProblemsController(AppContext appContext, ILogger<ProblemsController> log
             this.configuration = configuration;
         }
 
+        [HttpGet]
+        [Route("")]
+        public ActionResult<string> GetHome()
+        {
+            return Ok("Leetcode Wrapper Backend is running.");
+        }
+
         [HttpGet]
         [Route("problems")]
         public async Task<ActionResult<ProblemPublicModel>> GetProblems(
@@ -36,7 +43,8 @@ public async Task<ActionResult<ProblemPublicModel>> GetProblems(
         [Route("problems/{id}")]
         public async Task<ActionResult<ProblemPublicModel>> GetProblems(string id)
         {
-            if (appContext.dataProvider.problemsCache.TryGetValue(id, out var problem))
+            var problem = await appContext.dataProvider.GetProblemByIdAsync(id);
+            if (problem != null)
             {
                 return Ok(problem);
             }

src/Backend/Operations/DataProvider.cs

@@ -5,18 +5,20 @@ namespace Backend.Operations
 
     public class DataProvider
     {
-        private const int RefreshIntervalInHours = 6;
+        private const int RefreshIntervalInHours = 3;
         private CosmosClient cosmosClient;
         private readonly IConfiguration configuration;
         ILogger<DataProvider> logger;
         private DateTime lastLoadedTime = DateTime.MinValue;
-        public Dictionary<string, Problem> problemsCache { get;  private set; } = new Dictionary<string, Problem>(StringComparer.OrdinalIgnoreCase);
+        private Task backgroundRefreshTask;
+        private Dictionary<string, Problem> problemsCache = new Dictionary<string, Problem>(StringComparer.OrdinalIgnoreCase);
 
         public DataProvider(CosmosClient client, IConfiguration configuration, ILogger<DataProvider> logger)
         {
             this.cosmosClient = client;
             this.configuration = configuration;
             this.logger = logger;
+            this.backgroundRefreshTask = Task.Run(() => this.StartBackgroundRefreshAsync(CancellationToken.None));
         }
 
         public async Task<List<Problem>> GetProblemsAsync(IFilter? filter = null)
@@ -28,43 +30,80 @@ public async Task<List<Problem>> GetProblemsAsync(IFilter? filter = null)
             }
             return allProblems.Values.ToList();
         }
+
+        public async Task<Problem?> GetProblemByIdAsync(string id)
+        {
+            var allProblems = await GetAllProblemsAsync();
+            if (allProblems.TryGetValue(id, out var problem))
+            {
+                return problem;
+            }
+            return null;
+        }
 
         private async Task<Dictionary<string, Problem>> GetAllProblemsAsync()
         {
-            if ((DateTime.UtcNow - lastLoadedTime) > TimeSpan.FromHours(RefreshIntervalInHours))
+            if (problemsCache.Count == 0)
             {
                 await LoadLatestDataAsync();
+                if (problemsCache.Count == 0)
+                {
+                    this.logger.LogWarning("No problems found in the cache after loading data.");
+                }
             }
             return problemsCache;
         }
 
         private async Task LoadLatestDataAsync()
         {
-            try
+            int maxRetries = 3;
+            for(int i = 0; i < maxRetries; i++)
             {
-                var dbId = configuration.GetValue<string>("ApplicationSettings:CosmosDbDatabaseId");
-                var containerId = configuration.GetValue<string>("ApplicationSettings:CosmosDbContainerId");
-                var db = cosmosClient.GetDatabase(dbId);
-                var container = db.GetContainer(containerId);
+                try
+                {
+                    var dbId = configuration.GetValue<string>("ApplicationSettings:CosmosDbDatabaseId");
+                    var containerId = configuration.GetValue<string>("ApplicationSettings:CosmosDbContainerId");
+                    var db = cosmosClient.GetDatabase(dbId);
+                    var container = db.GetContainer(containerId);
+
+                    var query = "SELECT * FROM c";
+                    var queryDefinition = new QueryDefinition(query);
+                    var queryResultSetIterator = container.GetItemQueryIterator<ProblemSchema>(queryDefinition);
 
-                var query = "SELECT * FROM c";
-                var queryDefinition = new QueryDefinition(query);
-                var queryResultSetIterator = container.GetItemQueryIterator<ProblemSchema>(queryDefinition);
+                    List<Problem> results = new List<Problem>();
+                    while (queryResultSetIterator.HasMoreResults)
+                    {
+                        var response = await queryResultSetIterator.ReadNextAsync();
+                        results.AddRange(response.Select(item => new Problem(item)));
+                    }
 
-                List<Problem> results = new List<Problem>();
-                while (queryResultSetIterator.HasMoreResults)
+                    lastLoadedTime = DateTime.UtcNow;
+                    problemsCache = results.ToDictionary(p => p.id, StringComparer.OrdinalIgnoreCase);
+                    this.logger.LogInformation($"Loaded {problemsCache.Count} problems from Cosmos DB at {lastLoadedTime}");
+                    break;
+                }
+                catch (Exception ex)
                 {
-                    var response = await queryResultSetIterator.ReadNextAsync();
-                    results.AddRange(response.Select(item => new Problem(item)));
+                    this.logger.LogError($"Error loading data from Cosmos DB. {ex}");
+                    await Task.Delay(TimeSpan.FromSeconds(2 * (i + 1)));
                 }
-
-                lastLoadedTime = DateTime.UtcNow;
-                problemsCache = results.ToDictionary(p => p.id, StringComparer.OrdinalIgnoreCase);
-                this.logger.LogInformation($"Loaded {problemsCache.Count} problems from Cosmos DB at {lastLoadedTime}");
             }
-            catch (Exception ex)
+        }
+
+        public async Task StartBackgroundRefreshAsync(CancellationToken cancellationToken)
+        {
+            while (!cancellationToken.IsCancellationRequested)
             {
-                this.logger.LogError($"Error loading data from Cosmos DB. {ex}");
+                try
+                {
+                    await LoadLatestDataAsync();
+                }
+                catch (Exception ex)
+                {
+                    this.logger.LogError($"Error during background data refresh: {ex}");
+                }
+
+                await Task.Delay(TimeSpan.FromHours(RefreshIntervalInHours), cancellationToken);
             }
         }
     }