feat: implement Settings Service and watermark tracking (Issue #12)

- Add ISettingsService interface for key-value settings management
- Implement SettingsService with memory caching and thread-safe operations
- Add typed getter/setter methods for DateTimeOffset, DateOnly, int, etc.
- Implement watermark helper methods for rollup job tracking:
  - GetLastRollup15mTimestampAsync/SetLastRollup15mTimestampAsync
  - GetLastRollupDailyDateAsync/SetLastRollupDailyDateAsync
  - GetLastPruneTimestampAsync/SetLastPruneTimestampAsync
- Register SettingsService and MemoryCache in DI container
- Add batch operations for multiple settings
- Settings table already exists from Issue #10, leveraged existing entity

Functional testing confirmed:
- CRUD operations working correctly
- Typed conversions for DateTimeOffset and DateOnly
- Cache invalidation and thread-safe access
- Integration with existing seeded settings

Completes Phase 2 data layer foundation. Enables rollup jobs (Issues #27, #28).

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: hemanandr

.claude/settings.local.json

@@ -2,7 +2,10 @@
   "permissions": {
     "allow": [
       "Bash(dotnet format:*)",
-      "Bash(dotnet build)"
+      "Bash(dotnet build)",
+      "Bash(dotnet add package:*)",
+      "Bash(curl:*)",
+      "Bash(taskkill:*)"
     ],
     "deny": [],
     "ask": []

ThingConnect.Pulse.Server/Program.cs

@@ -16,9 +16,13 @@ public static void Main(string[] args)
         builder.Services.AddDbContext<PulseDbContext>(options =>
             options.UseSqlite(builder.Configuration.GetConnectionString("DefaultConnection")));
 
+        // Add memory cache for settings service
+        builder.Services.AddMemoryCache();
+
         // Add configuration services
         builder.Services.AddSingleton<ConfigParser>();
         builder.Services.AddScoped<IConfigurationService, ConfigurationService>();
+        builder.Services.AddScoped<ISettingsService, SettingsService>();
 
         builder.Services.AddControllers(options =>
         {

ThingConnect.Pulse.Server/Services/ISettingsService.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace ThingConnect.Pulse.Server.Services;
+
+public interface ISettingsService
+{
+    Task<string?> GetAsync(string key);
+    Task SetAsync(string key, string value);
+    Task<T?> GetAsync<T>(string key) where T : struct;
+    Task<T?> GetAsync<T>(string key, T defaultValue) where T : struct;
+    Task SetAsync<T>(string key, T value) where T : struct;
+    Task<Dictionary<string, string>> GetManyAsync(params string[] keys);
+    Task SetManyAsync(Dictionary<string, string> values);
+    Task DeleteAsync(string key);
+    Task<bool> ExistsAsync(string key);
+    
+    Task<DateTimeOffset?> GetLastRollup15mTimestampAsync();
+    Task SetLastRollup15mTimestampAsync(DateTimeOffset timestamp);
+    
+    Task<DateOnly?> GetLastRollupDailyDateAsync();
+    Task SetLastRollupDailyDateAsync(DateOnly date);
+    
+    Task<DateTimeOffset?> GetLastPruneTimestampAsync();
+    Task SetLastPruneTimestampAsync(DateTimeOffset timestamp);
+    
+    Task<string?> GetVersionAsync();
+    Task SetVersionAsync(string version);
+}

ThingConnect.Pulse.Server/Services/SettingsService.cs

@@ -0,0 +1,301 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Caching.Memory;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using ThingConnect.Pulse.Server.Data;
+
+namespace ThingConnect.Pulse.Server.Services;
+
+public sealed class SettingsService : ISettingsService
+{
+    private readonly PulseDbContext _context;
+    private readonly IMemoryCache _cache;
+    private readonly SemaphoreSlim _semaphore;
+    private readonly TimeSpan _cacheExpiration = TimeSpan.FromMinutes(5);
+    
+    private const string LastRollup15mKey = "last_rollup_15m";
+    private const string LastRollupDailyKey = "last_rollup_daily";
+    private const string LastPruneKey = "last_prune";
+    private const string VersionKey = "version";
+
+    public SettingsService(PulseDbContext context, IMemoryCache cache)
+    {
+        _context = context;
+        _cache = cache;
+        _semaphore = new SemaphoreSlim(1, 1);
+    }
+
+    public async Task<string?> GetAsync(string key)
+    {
+        var cacheKey = $"setting:{key}";
+        
+        if (_cache.TryGetValue(cacheKey, out string? cachedValue))
+        {
+            return cachedValue;
+        }
+
+        await _semaphore.WaitAsync();
+        try
+        {
+            if (_cache.TryGetValue(cacheKey, out cachedValue))
+            {
+                return cachedValue;
+            }
+
+            var setting = await _context.Settings
+                .FirstOrDefaultAsync(s => s.K == key);
+
+            var value = setting?.V;
+            _cache.Set(cacheKey, value, _cacheExpiration);
+            
+            return value;
+        }
+        finally
+        {
+            _semaphore.Release();
+        }
+    }
+
+    public async Task SetAsync(string key, string value)
+    {
+        await _semaphore.WaitAsync();
+        try
+        {
+            var setting = await _context.Settings
+                .FirstOrDefaultAsync(s => s.K == key);
+
+            if (setting == null)
+            {
+                setting = new Setting { K = key, V = value };
+                _context.Settings.Add(setting);
+            }
+            else
+            {
+                setting.V = value;
+            }
+
+            await _context.SaveChangesAsync();
+            
+            var cacheKey = $"setting:{key}";
+            _cache.Set(cacheKey, value, _cacheExpiration);
+        }
+        finally
+        {
+            _semaphore.Release();
+        }
+    }
+
+    public async Task<T?> GetAsync<T>(string key) where T : struct
+    {
+        var stringValue = await GetAsync(key);
+        if (string.IsNullOrEmpty(stringValue))
+        {
+            return null;
+        }
+
+        return ConvertToType<T>(stringValue);
+    }
+
+    public async Task<T?> GetAsync<T>(string key, T defaultValue) where T : struct
+    {
+        var result = await GetAsync<T>(key);
+        return result ?? defaultValue;
+    }
+
+    public async Task SetAsync<T>(string key, T value) where T : struct
+    {
+        var stringValue = ConvertToString(value);
+        await SetAsync(key, stringValue);
+    }
+
+    public async Task<Dictionary<string, string>> GetManyAsync(params string[] keys)
+    {
+        var result = new Dictionary<string, string>();
+        
+        foreach (var key in keys)
+        {
+            var value = await GetAsync(key);
+            if (value != null)
+            {
+                result[key] = value;
+            }
+        }
+        
+        return result;
+    }
+
+    public async Task SetManyAsync(Dictionary<string, string> values)
+    {
+        await _semaphore.WaitAsync();
+        try
+        {
+            var existingSettings = await _context.Settings
+                .Where(s => values.Keys.Contains(s.K))
+                .ToListAsync();
+
+            foreach (var kvp in values)
+            {
+                var existing = existingSettings.FirstOrDefault(s => s.K == kvp.Key);
+                if (existing == null)
+                {
+                    _context.Settings.Add(new Setting { K = kvp.Key, V = kvp.Value });
+                }
+                else
+                {
+                    existing.V = kvp.Value;
+                }
+
+                var cacheKey = $"setting:{kvp.Key}";
+                _cache.Set(cacheKey, kvp.Value, _cacheExpiration);
+            }
+
+            await _context.SaveChangesAsync();
+        }
+        finally
+        {
+            _semaphore.Release();
+        }
+    }
+
+    public async Task DeleteAsync(string key)
+    {
+        await _semaphore.WaitAsync();
+        try
+        {
+            var setting = await _context.Settings
+                .FirstOrDefaultAsync(s => s.K == key);
+
+            if (setting != null)
+            {
+                _context.Settings.Remove(setting);
+                await _context.SaveChangesAsync();
+            }
+
+            var cacheKey = $"setting:{key}";
+            _cache.Remove(cacheKey);
+        }
+        finally
+        {
+            _semaphore.Release();
+        }
+    }
+
+    public async Task<bool> ExistsAsync(string key)
+    {
+        var value = await GetAsync(key);
+        return value != null;
+    }
+
+    public async Task<DateTimeOffset?> GetLastRollup15mTimestampAsync()
+    {
+        return await GetAsync<DateTimeOffset>(LastRollup15mKey);
+    }
+
+    public async Task SetLastRollup15mTimestampAsync(DateTimeOffset timestamp)
+    {
+        await SetAsync(LastRollup15mKey, timestamp);
+    }
+
+    public async Task<DateOnly?> GetLastRollupDailyDateAsync()
+    {
+        return await GetAsync<DateOnly>(LastRollupDailyKey);
+    }
+
+    public async Task SetLastRollupDailyDateAsync(DateOnly date)
+    {
+        await SetAsync(LastRollupDailyKey, date);
+    }
+
+    public async Task<DateTimeOffset?> GetLastPruneTimestampAsync()
+    {
+        return await GetAsync<DateTimeOffset>(LastPruneKey);
+    }
+
+    public async Task SetLastPruneTimestampAsync(DateTimeOffset timestamp)
+    {
+        await SetAsync(LastPruneKey, timestamp);
+    }
+
+    public async Task<string?> GetVersionAsync()
+    {
+        return await GetAsync(VersionKey);
+    }
+
+    public async Task SetVersionAsync(string version)
+    {
+        await SetAsync(VersionKey, version);
+    }
+
+    private static T? ConvertToType<T>(string value) where T : struct
+    {
+        try
+        {
+            if (typeof(T) == typeof(DateTimeOffset))
+            {
+                if (DateTimeOffset.TryParse(value, null, DateTimeStyles.RoundtripKind, out var dateTimeOffset))
+                {
+                    return (T)(object)dateTimeOffset;
+                }
+            }
+            else if (typeof(T) == typeof(DateOnly))
+            {
+                if (DateOnly.TryParse(value, out var dateOnly))
+                {
+                    return (T)(object)dateOnly;
+                }
+            }
+            else if (typeof(T) == typeof(int))
+            {
+                if (int.TryParse(value, out var intValue))
+                {
+                    return (T)(object)intValue;
+                }
+            }
+            else if (typeof(T) == typeof(long))
+            {
+                if (long.TryParse(value, out var longValue))
+                {
+                    return (T)(object)longValue;
+                }
+            }
+            else if (typeof(T) == typeof(bool))
+            {
+                if (bool.TryParse(value, out var boolValue))
+                {
+                    return (T)(object)boolValue;
+                }
+            }
+            else if (typeof(T) == typeof(double))
+            {
+                if (double.TryParse(value, out var doubleValue))
+                {
+                    return (T)(object)doubleValue;
+                }
+            }
+        }
+        catch
+        {
+            // Return null on any conversion failure
+        }
+
+        return null;
+    }
+
+    private static string ConvertToString<T>(T value) where T : struct
+    {
+        if (typeof(T) == typeof(DateTimeOffset))
+        {
+            return ((DateTimeOffset)(object)value).ToString("O");
+        }
+        else if (typeof(T) == typeof(DateOnly))
+        {
+            return ((DateOnly)(object)value).ToString("yyyy-MM-dd");
+        }
+        
+        return value.ToString() ?? string.Empty;
+    }
+}

ThingConnect.Pulse.Server/obj/Debug/net8.0/ThingConnect.Pulse.Server.AssemblyInfo.cs

@@ -14,7 +14,7 @@
 [assembly: System.Reflection.AssemblyConfigurationAttribute("Debug")]
 [assembly: System.Reflection.AssemblyCopyrightAttribute("Copyright © ThingConnect")]
 [assembly: System.Reflection.AssemblyFileVersionAttribute("1.0.0.0")]
-[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+c6abc4babd345cead550af112cefb8d49d7b8e90")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.0.0+8a960969e22b060d78db78b8c40357814a606169")]
 [assembly: System.Reflection.AssemblyProductAttribute("ThingConnect Pulse")]
 [assembly: System.Reflection.AssemblyTitleAttribute("ThingConnect.Pulse.Server")]
 [assembly: System.Reflection.AssemblyVersionAttribute("1.0.0.0")]

ThingConnect.Pulse.Server/obj/Debug/net8.0/ThingConnect.Pulse.Server.AssemblyInfoInputs.cache

@@ -1 +1 @@
-19d72d003ff78fb0ef36fda9d2dfbdf7debdcbde88edb0714a061ee2349d2e72
+db6411c501c204aa56233767458ea00081da3f7c0f7aff2c3cc201e1ad2b21b6

ThingConnect.Pulse.Server/obj/Debug/net8.0/ThingConnect.Pulse.Server.assets.cache

@@ -1 +1 @@
-{"GlobalPropertiesHash":"9PK/OGCf+RzB4m3f+iTtM4wrt+FifsN+qUnFZIesk+g=","FingerprintPatternsHash":"gq3WsqcKBUGTSNle7RKKyXRIwh7M8ccEqOqYvIzoM04=","PropertyOverridesHash":"8ZRc1sGeVrPBx4lD717BgRaQekyh78QKV9SKsdt638U=","InputHashes":["cJoK5obhTAwfod5MYOINhtAzyuvHSObg/BC6V13Rdps=","xHnJxM/KqSX72yPdHJARz9P2KMJy0x90ysywKPc9tZQ="],"CachedAssets":{},"CachedCopyCandidates":{}}
+{"GlobalPropertiesHash":"9PK/OGCf+RzB4m3f+iTtM4wrt+FifsN+qUnFZIesk+g=","FingerprintPatternsHash":"gq3WsqcKBUGTSNle7RKKyXRIwh7M8ccEqOqYvIzoM04=","PropertyOverridesHash":"8ZRc1sGeVrPBx4lD717BgRaQekyh78QKV9SKsdt638U=","InputHashes":["C6Jjvpuerd39Yox3lGG\u002Bp6FAssMvUh7MY5AKsRRnRag=","Ex39stWnH\u002BmhdI4V5jYTrZmxOWibKu1SRPLZyJMpWTc="],"CachedAssets":{},"CachedCopyCandidates":{}}