feat: add push notification infrastructure for FCM

Add device token storage (DeviceToken entity, DbContext, REST + gRPC endpoints),
Firebase Admin SDK integration with conditional initialization, and fire-and-forget
push triggers in AbsenceRequestService and ContentHandoverService for create/approve/reject flows.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: renemadsen

eFormAPI/Plugins/TimePlanning.Pn/TimePlanning.Pn.Test/AbsenceRequestServiceTests.cs

@@ -50,7 +50,8 @@ public async Task SetUp()
             _userService,
             _localizationService,
             _coreService,
-            baseDbContext);
+            baseDbContext,
+            Substitute.For<TimePlanning.Pn.Services.PushNotificationService.IPushNotificationService>());
     }
 
     [Test]

eFormAPI/Plugins/TimePlanning.Pn/TimePlanning.Pn.Test/ContentHandoverServiceTests.cs

@@ -40,7 +40,8 @@ public async Task SetUp()
             _userService,
             _localizationService,
             Substitute.For<Microting.eFormApi.BasePn.Abstractions.IEFormCoreService>(),
-            baseDbContext);
+            baseDbContext,
+            Substitute.For<TimePlanning.Pn.Services.PushNotificationService.IPushNotificationService>());
     }
 
     // GetHandoverEligibleCoworkersAsync exercises the real SDK MicrotingDbContext (Workers,

eFormAPI/Plugins/TimePlanning.Pn/TimePlanning.Pn/Controllers/DeviceTokenController.cs

@@ -0,0 +1,74 @@
+#nullable enable
+namespace TimePlanning.Pn.Controllers;
+
+using System.Linq;
+using System.Threading.Tasks;
+using Infrastructure.Models.DeviceToken;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Microting.eForm.Infrastructure.Constants;
+using Microting.EformAngularFrontendBase.Infrastructure.Data;
+using Microting.eFormApi.BasePn.Abstractions;
+using Microting.eFormApi.BasePn.Infrastructure.Models.API;
+using Services.DeviceTokenService;
+
+[Route("api/time-planning-pn/device-tokens")]
+public class DeviceTokenController : Controller
+{
+    private readonly IDeviceTokenService _deviceTokenService;
+    private readonly IUserService _userService;
+    private readonly IEFormCoreService _coreService;
+    private readonly BaseDbContext _baseDbContext;
+
+    public DeviceTokenController(
+        IDeviceTokenService deviceTokenService,
+        IUserService userService,
+        IEFormCoreService coreService,
+        BaseDbContext baseDbContext)
+    {
+        _deviceTokenService = deviceTokenService;
+        _userService = userService;
+        _coreService = coreService;
+        _baseDbContext = baseDbContext;
+    }
+
+    [HttpPost]
+    public async Task<OperationResult> Register([FromBody] RegisterDeviceTokenModel model)
+    {
+        var sdkSiteId = await ResolveCallerSdkSiteIdAsync();
+        if (sdkSiteId == 0)
+        {
+            return new OperationResult(false, "Could not resolve caller SdkSiteId");
+        }
+
+        return await _deviceTokenService.RegisterAsync(sdkSiteId, model.Token, model.Platform);
+    }
+
+    [HttpDelete]
+    public async Task<OperationResult> Unregister([FromBody] UnregisterDeviceTokenModel model)
+    {
+        return await _deviceTokenService.UnregisterAsync(model.Token);
+    }
+
+    private async Task<int> ResolveCallerSdkSiteIdAsync()
+    {
+        var currentUserAsync = await _userService.GetCurrentUserAsync();
+        var currentUser = _baseDbContext.Users
+            .Single(x => x.Id == currentUserAsync.Id);
+
+        var sdkCore = await _coreService.GetCore();
+        var sdkDbContext = sdkCore.DbContextHelper.GetDbContext();
+
+        var worker = await sdkDbContext.Workers
+            .Include(x => x.SiteWorkers)
+            .ThenInclude(x => x.Site)
+            .Where(x => x.WorkflowState != Constants.WorkflowStates.Removed)
+            .FirstOrDefaultAsync(x => x.Email == currentUser.Email);
+
+        if (worker == null || worker.SiteWorkers.Count == 0)
+        {
+            return 0;
+        }
+        return worker.SiteWorkers.First().Site.MicrotingUid ?? 0;
+    }
+}

eFormAPI/Plugins/TimePlanning.Pn/TimePlanning.Pn/EformTimePlanningPlugin.cs

@@ -38,6 +38,9 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 using TimePlanning.Pn.Services.PayTierRuleService;
 using TimePlanning.Pn.Services.PayTimeBandRuleService;
 using TimePlanning.Pn.Services.PayrollExportService;
+using TimePlanning.Pn.Services.DeviceTokenService;
+using TimePlanning.Pn.Services.PushNotificationService;
+using TimePlanning.Pn.Infrastructure.Models.DeviceToken;
 using Constants = Microting.eForm.Infrastructure.Constants.Constants;
 
 namespace TimePlanning.Pn;
@@ -107,6 +110,8 @@ public void ConfigureServices(IServiceCollection services)
         services.AddTransient<IPayTierRuleService, PayTierRuleService>();
         services.AddTransient<IPayTimeBandRuleService, PayTimeBandRuleService>();
         services.AddTransient<IPayrollExportService, PayrollExportService>();
+        services.AddTransient<IDeviceTokenService, DeviceTokenService>();
+        services.AddSingleton<IPushNotificationService, PushNotificationService>();
         services.AddControllers();
     }
 
@@ -187,6 +192,14 @@ public void ConfigureDbContext(IServiceCollection services, string connectionStr
             }));
 
 
+        services.AddDbContext<DeviceTokenDbContext>(o =>
+            o.UseMySql(connectionString, new MariaDbServerVersion(
+                ServerVersion.AutoDetect(connectionString)), mySqlOptionsAction: builder =>
+            {
+                builder.EnableRetryOnFailure();
+                builder.MigrationsAssembly(PluginAssembly().FullName);
+            }));
+
         services.AddDbContext<BaseDbContext>(
             o => o.UseMySql(frontendBaseConnectionString, new MariaDbServerVersion(
                 ServerVersion.AutoDetect(frontendBaseConnectionString)), mySqlOptionsAction: builder =>
@@ -201,6 +214,23 @@ public void ConfigureDbContext(IServiceCollection services, string connectionStr
         context.Database.Migrate();
         Console.WriteLine("TimePlanningPnDbContext migrated to latest version");
 
+        // Ensure DeviceTokens table exists (raw SQL to avoid EnsureCreated conflicts)
+        Console.WriteLine("Ensuring DeviceTokens table exists");
+        context.Database.ExecuteSqlRaw(@"
+            CREATE TABLE IF NOT EXISTS `DeviceTokens` (
+                `Id` int NOT NULL AUTO_INCREMENT,
+                `SdkSiteId` int NOT NULL,
+                `Token` varchar(512) NOT NULL,
+                `Platform` varchar(16) NOT NULL,
+                `CreatedAt` datetime(6) NOT NULL,
+                `UpdatedAt` datetime(6) NOT NULL,
+                `WorkflowState` varchar(50) NULL DEFAULT 'created',
+                PRIMARY KEY (`Id`),
+                UNIQUE INDEX `IX_DeviceTokens_Token` (`Token`),
+                INDEX `IX_DeviceTokens_SdkSiteId` (`SdkSiteId`)
+            ) CHARACTER SET=utf8mb4;
+        ");
+
         // Seed database
         SeedDatabase(connectionString);
     }
@@ -216,6 +246,7 @@ public void Configure(IApplicationBuilder appBuilder)
             endpoints.MapGrpcService<TimePlanningPlanningsGrpcService>();
             endpoints.MapGrpcService<TimePlanningAbsenceRequestGrpcService>();
             endpoints.MapGrpcService<TimePlanningContentHandoverGrpcService>();
+            endpoints.MapGrpcService<TimePlanningDeviceTokenGrpcService>();
         });
     }
 

eFormAPI/Plugins/TimePlanning.Pn/TimePlanning.Pn/Infrastructure/Models/DeviceToken/DeviceToken.cs

@@ -0,0 +1,27 @@
+namespace TimePlanning.Pn.Infrastructure.Models.DeviceToken;
+
+using System;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+[Table("DeviceTokens")]
+public class DeviceToken
+{
+    [Key]
+    public int Id { get; set; }
+    public int SdkSiteId { get; set; }
+
+    [Required]
+    [MaxLength(512)]
+    public string Token { get; set; } = string.Empty;
+
+    [Required]
+    [MaxLength(16)]
+    public string Platform { get; set; } = string.Empty; // "android" or "ios"
+
+    public DateTime CreatedAt { get; set; }
+    public DateTime UpdatedAt { get; set; }
+
+    [MaxLength(50)]
+    public string WorkflowState { get; set; } = "created";
+}

eFormAPI/Plugins/TimePlanning.Pn/TimePlanning.Pn/Infrastructure/Models/DeviceToken/DeviceTokenDbContext.cs

@@ -0,0 +1,24 @@
+namespace TimePlanning.Pn.Infrastructure.Models.DeviceToken;
+
+using Microsoft.EntityFrameworkCore;
+
+public class DeviceTokenDbContext : DbContext
+{
+    public DeviceTokenDbContext(DbContextOptions<DeviceTokenDbContext> options)
+        : base(options)
+    {
+    }
+
+    public DbSet<DeviceToken> DeviceTokens { get; set; } = null!;
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        base.OnModelCreating(modelBuilder);
+
+        modelBuilder.Entity<DeviceToken>(entity =>
+        {
+            entity.HasIndex(e => e.Token).IsUnique();
+            entity.HasIndex(e => e.SdkSiteId);
+        });
+    }
+}

eFormAPI/Plugins/TimePlanning.Pn/TimePlanning.Pn/Infrastructure/Models/DeviceToken/RegisterDeviceTokenModel.cs

@@ -0,0 +1,7 @@
+namespace TimePlanning.Pn.Infrastructure.Models.DeviceToken;
+
+public class RegisterDeviceTokenModel
+{
+    public string Token { get; set; } = string.Empty;
+    public string Platform { get; set; } = string.Empty;
+}

eFormAPI/Plugins/TimePlanning.Pn/TimePlanning.Pn/Infrastructure/Models/DeviceToken/UnregisterDeviceTokenModel.cs

@@ -0,0 +1,6 @@
+namespace TimePlanning.Pn.Infrastructure.Models.DeviceToken;
+
+public class UnregisterDeviceTokenModel
+{
+    public string Token { get; set; } = string.Empty;
+}

eFormAPI/Plugins/TimePlanning.Pn/TimePlanning.Pn/Protos/device_token.proto

@@ -0,0 +1,22 @@
+syntax = "proto3";
+
+package timeplanning;
+
+import "common.proto";
+
+option csharp_namespace = "TimePlanning.Pn.Grpc";
+
+message RegisterDeviceTokenRequest {
+  string token = 1;
+  string platform = 2;
+  int32 sdk_site_id = 3;
+}
+
+message UnregisterDeviceTokenRequest {
+  string token = 1;
+}
+
+service TimePlanningDeviceTokenService {
+  rpc RegisterDeviceToken(RegisterDeviceTokenRequest) returns (OperationResponse);
+  rpc UnregisterDeviceToken(UnregisterDeviceTokenRequest) returns (OperationResponse);
+}

eFormAPI/Plugins/TimePlanning.Pn/TimePlanning.Pn/Services/AbsenceRequestService/AbsenceRequestService.cs

@@ -40,6 +40,7 @@ namespace TimePlanning.Pn.Services.AbsenceRequestService;
 using Microting.eForm.Infrastructure.Constants;
 using Microting.eFormApi.BasePn.Infrastructure.Helpers;
 using Microting.EformAngularFrontendBase.Infrastructure.Data;
+using TimePlanning.Pn.Services.PushNotificationService;
 using TimePlanningLocalizationService;
 
 public class AbsenceRequestService : IAbsenceRequestService
@@ -50,21 +51,24 @@ public class AbsenceRequestService : IAbsenceRequestService
     private readonly ITimePlanningLocalizationService _localizationService;
     private readonly IEFormCoreService _coreService;
     private readonly BaseDbContext _baseDbContext;
+    private readonly IPushNotificationService _pushNotificationService;
 
     public AbsenceRequestService(
         ILogger<AbsenceRequestService> logger,
         TimePlanningPnDbContext dbContext,
         IUserService userService,
         ITimePlanningLocalizationService localizationService,
         IEFormCoreService coreService,
-        BaseDbContext baseDbContext)
+        BaseDbContext baseDbContext,
+        IPushNotificationService pushNotificationService)
     {
         _logger = logger;
         _dbContext = dbContext;
         _userService = userService;
         _localizationService = localizationService;
         _coreService = coreService;
         _baseDbContext = baseDbContext;
+        _pushNotificationService = pushNotificationService;
     }
 
     /// <summary>
@@ -159,6 +163,47 @@ public async Task<OperationDataResult<AbsenceRequestModel>> CreateAsync(AbsenceR
                 .FirstAsync(ar => ar.Id == absenceRequest.Id);
 
             var resultModel = MapToModel(createdRequest);
+
+            // Fire-and-forget push to manager(s)
+            _ = Task.Run(async () =>
+            {
+                try
+                {
+                    // Find managers for this worker's tags
+                    var sdkCore = await _coreService.GetCore();
+                    var sdkDbContext = sdkCore.DbContextHelper.GetDbContext();
+                    var workerTagIds = await sdkDbContext.SiteTags
+                        .Where(x => x.Site.MicrotingUid == model.RequestedBySdkSitId
+                                    && x.WorkflowState != Microting.eForm.Infrastructure.Constants.Constants.WorkflowStates.Removed)
+                        .Select(x => (int)x.TagId!)
+                        .ToListAsync();
+
+                    var managerSiteIds = await _dbContext.AssignedSiteManagingTags
+                        .Where(x => x.WorkflowState != Microting.eForm.Infrastructure.Constants.Constants.WorkflowStates.Removed
+                                    && workerTagIds.Contains(x.TagId))
+                        .Select(x => x.AssignedSite!.SiteId)
+                        .Distinct()
+                        .ToListAsync();
+
+                    foreach (var managerSiteId in managerSiteIds)
+                    {
+                        await _pushNotificationService.SendToSiteAsync(
+                            managerSiteId,
+                            "New absence request",
+                            "A worker has requested time off",
+                            new Dictionary<string, string>
+                            {
+                                { "type", "absence_created" },
+                                { "absenceRequestId", createdRequest.Id.ToString() }
+                            });
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error sending push notification for absence request creation");
+                }
+            });
+
             return new OperationDataResult<AbsenceRequestModel>(true, resultModel);
         }
         catch (Exception ex)
@@ -207,6 +252,29 @@ public async Task<OperationResult> ApproveAsync(int absenceRequestId, AbsenceReq
                 await ApplyAbsenceToPlanRegistration(request, day);
             }
 
+            // Fire-and-forget push to requester
+            var requesterSdkSitId = request.RequestedBySdkSitId;
+            _ = Task.Run(async () =>
+            {
+                try
+                {
+                    await _pushNotificationService.SendToSiteAsync(
+                        requesterSdkSitId,
+                        "Absence request approved",
+                        "Your absence request has been approved",
+                        new Dictionary<string, string>
+                        {
+                            { "type", "absence_decided" },
+                            { "action", "approved" },
+                            { "absenceRequestId", absenceRequestId.ToString() }
+                        });
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error sending push notification for absence approval");
+                }
+            });
+
             return new OperationResult(true);
         }
         catch (Exception ex)
@@ -240,6 +308,29 @@ public async Task<OperationResult> RejectAsync(int absenceRequestId, AbsenceRequ
             request.UpdatedByUserId = _userService.UserId;
             await request.Update(_dbContext);
 
+            // Fire-and-forget push to requester
+            var requesterSdkSitId = request.RequestedBySdkSitId;
+            _ = Task.Run(async () =>
+            {
+                try
+                {
+                    await _pushNotificationService.SendToSiteAsync(
+                        requesterSdkSitId,
+                        "Absence request rejected",
+                        "Your absence request has been rejected",
+                        new Dictionary<string, string>
+                        {
+                            { "type", "absence_decided" },
+                            { "action", "rejected" },
+                            { "absenceRequestId", absenceRequestId.ToString() }
+                        });
+                }
+                catch (Exception ex)
+                {
+                    _logger.LogError(ex, "Error sending push notification for absence rejection");
+                }
+            });
+
             return new OperationResult(true);
         }
         catch (Exception ex)