Feature: Global Activity Templates

using Leadmetrics.Data.Shared.Attributes;
using Leadmetrics.Data.Shared.Entities;
using System;
using System.Collections.Generic;
 
namespace Leadmetrics.Feature.Activities.Entities
{
    [CollectionName("GlobalActivityTemplates")]
    public class GlobalActivityTemplate : BaseEntity
    {
        public string Title { get; set; }
        public string Description { get; set; }
        public List<string> Channels { get; set; } = new();
        public List<string> Tags { get; set; } = new();
        public string Type { get; set; }
        public int DueInDays { get; set; }
        public string Frequency { get; set; }
        public string EntityType { get; set; }
        public string EntitySubType { get; set; }
        public string TriggerEvent { get; set; }
        public bool IsActive { get; set; } = true;
        public DateTime? UpdatedOn { get; set; }
    }
}

// Link back to the global master template (null = fully custom)
public string GlobalTemplateId { get; set; }
 
// True if the tenant has manually edited this copy
public bool IsCustomized { get; set; } = false;

using Leadmetrics.Feature.Activities.DTOs;
using Leadmetrics.Feature.Activities.Entities;
using Leadmetrics.Feature.Activities.Models;
using System.Collections.Generic;
using System.Threading.Tasks;
 
namespace Leadmetrics.Feature.Activities.Services
{
    public interface IGlobalActivityTemplateService
    {
        // Read
        Task<GlobalActivityTemplate> GetByIdAsync(string id);
        Task<List<GlobalActivityTemplate>> GetByTriggerAsync(string entitySubType, string triggerEvent);
        Task<PagedResult<GlobalActivityTemplate>> SearchAsync(GlobalActivityTemplateFilterDTO filter, int page, int size);
        Task<GlobalActivityTemplateCopiesSummaryDTO> GetCopiesSummaryAsync(string globalTemplateId);
 
        // Write — userId and tenantId are passed from the controller for audit logging
        Task<GlobalActivityTemplate> CreateAsync(NewGlobalActivityTemplateModel model, string userId, string tenantId);
        Task<GlobalActivityTemplate> UpdateAsync(string id, NewGlobalActivityTemplateModel model, string userId, string tenantId);
        Task<GlobalActivityTemplate> ReactivateAsync(string id, string userId, string tenantId);
        Task<GlobalActivityTemplate> DeactivateAsync(string id, string userId, string tenantId);
 
        // Propagation (called by background worker; userId = initiating admin from task message)
        Task<GlobalActivityTemplateSyncResultDTO> SyncToTenantTemplatesAsync(string globalTemplateId, string userId, string tenantId);
        Task<GlobalActivityTemplateDeactivateResultDTO> PropagateDeactivationAsync(string globalTemplateId, string userId, string tenantId);
        Task<int> PushToExistingEntitiesAsync(string globalTemplateId, string userId, string tenantId);
    }
}

namespace Leadmetrics.Feature.Activities.DTOs
{
    public record GlobalActivityTemplateFilterDTO(
        string EntityType,
        string EntitySubType,
        string TriggerEvent,
        string Type,
        bool? IsActive,
        string Search
    );
 
    public record GlobalActivityTemplateSyncResultDTO(int UpdatedCount);
 
    public record GlobalActivityTemplateDeactivateResultDTO(
        int DeactivatedCount,
        int SkippedCustomizedCount
    );
 
    public record GlobalActivityTemplateCopiesSummaryDTO(
        int TotalCopies,
        int NonCustomizedCopies,
        int CustomizedCopies
    );
 
    public record GlobalTemplatePropagationQueuedDTO(
        string GlobalTemplateId,
        string OperationType,
        string Status = "queued"
    );
}

using System.Collections.Generic;
 
namespace Leadmetrics.Feature.Activities.Models
{
    public class NewGlobalActivityTemplateModel
    {
        public string Title { get; set; }
        public string Description { get; set; }
        public List<string> Channels { get; set; } = new();
        public List<string> Tags { get; set; } = new();
        public string Type { get; set; }
        public int DueInDays { get; set; }
        public string Frequency { get; set; }
        public string EntityType { get; set; }
        public string EntitySubType { get; set; }
        public string TriggerEvent { get; set; }
    }
}

using AutoMapper;
using Leadmetrics.Data.Common.Repositories;
using Leadmetrics.Data.Shared.Entities;
using Leadmetrics.Feature.Activities.DTOs;
using Leadmetrics.Feature.Activities.Entities;
using Leadmetrics.Feature.Activities.Models;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
 
namespace Leadmetrics.Feature.Activities.Services
{
    public class GlobalActivityTemplateService : IGlobalActivityTemplateService
    {
        private readonly IGenericRepository<GlobalActivityTemplate> _globalRepo;
        private readonly IGenericRepository<ActivityTemplate> _templateRepo;
        private readonly IMapper _mapper;
        private readonly IAuditLogService _auditLogService;
 
        public GlobalActivityTemplateService(
            IGenericRepository<GlobalActivityTemplate> globalRepo,
            IGenericRepository<ActivityTemplate> templateRepo,
            IMapper mapper,
            IAuditLogService auditLogService)
        {
            _globalRepo = globalRepo;
            _templateRepo = templateRepo;
            _mapper = mapper;
            _auditLogService = auditLogService;
        }
 
        public async Task<GlobalActivityTemplate> GetByIdAsync(string id)
            => await _globalRepo.GetByIdAsync(id);
 
        public async Task<List<GlobalActivityTemplate>> GetByTriggerAsync(string entitySubType, string triggerEvent)
        {
            var filter = Builders<GlobalActivityTemplate>.Filter.And(
                Builders<GlobalActivityTemplate>.Filter.Eq(x => x.EntitySubType, entitySubType),
                Builders<GlobalActivityTemplate>.Filter.Eq(x => x.TriggerEvent, triggerEvent),
                Builders<GlobalActivityTemplate>.Filter.Eq(x => x.IsActive, true)
            );
            return await _globalRepo.FindAsync(filter);
        }
 
        public async Task<GlobalActivityTemplate> CreateAsync(NewGlobalActivityTemplateModel model, string userId, string tenantId)
        {
            var entity = _mapper.Map<GlobalActivityTemplate>(model);
            entity.IsActive = true;
            entity.UpdatedOn = DateTime.UtcNow;
            await _globalRepo.InsertAsync(entity);
 
            var auditLog = AuditLogModel.Create(
                AuditLogCategory.EntityCRUD,
                AuditLogEntityType.GlobalActivityTemplate,
                AuditLogOperationType.Create,
                entity.Id,
                JsonConvert.SerializeObject(entity));
            await _auditLogService.CreateAuditLogAsync(auditLog, userId, tenantId);
 
            return entity;
        }
 
        public async Task<GlobalActivityTemplate> UpdateAsync(string id, NewGlobalActivityTemplateModel model, string userId, string tenantId)
        {
            var entity = await _globalRepo.GetByIdAsync(id);
            _mapper.Map(model, entity);
            entity.UpdatedOn = DateTime.UtcNow;
            await _globalRepo.UpdateAsync(entity);
 
            var auditLog = AuditLogModel.Create(
                AuditLogCategory.EntityCRUD,
                AuditLogEntityType.GlobalActivityTemplate,
                AuditLogOperationType.Update,
                entity.Id,
                JsonConvert.SerializeObject(entity));
            await _auditLogService.CreateAuditLogAsync(auditLog, userId, tenantId);
 
            return entity;
        }
 
        public async Task<GlobalActivityTemplate> DeactivateAsync(string id, string userId, string tenantId)
        {
            var entity = await _globalRepo.GetByIdAsync(id);
            entity.IsActive = false;
            entity.UpdatedOn = DateTime.UtcNow;
            await _globalRepo.UpdateAsync(entity);
 
            var auditLog = AuditLogModel.Create(
                AuditLogCategory.EntityCRUD,
                AuditLogEntityType.GlobalActivityTemplate,
                AuditLogOperationType.Delete,
                entity.Id,
                JsonConvert.SerializeObject(entity));
            await _auditLogService.CreateAuditLogAsync(auditLog, userId, tenantId);
 
            return entity;
        }
 
        public async Task<GlobalActivityTemplate> ReactivateAsync(string id, string userId, string tenantId)
        {
            var entity = await _globalRepo.GetByIdAsync(id);
            entity.IsActive = true;
            entity.UpdatedOn = DateTime.UtcNow;
            await _globalRepo.UpdateAsync(entity);
 
            var auditLog = AuditLogModel.Create(
                AuditLogCategory.EntityCRUD,
                AuditLogEntityType.GlobalActivityTemplate,
                AuditLogOperationType.Update,
                entity.Id,
                $"Reactivated GlobalActivityTemplate: {entity.Title}");
            await _auditLogService.CreateAuditLogAsync(auditLog, userId, tenantId);
 
            return entity;
        }
 
        public async Task<GlobalActivityTemplateCopiesSummaryDTO> GetCopiesSummaryAsync(string globalTemplateId)
        {
            var filter = Builders<ActivityTemplate>.Filter.Eq(x => x.GlobalTemplateId, globalTemplateId);
            var copies = await _templateRepo.FindAsync(filter);
            int total = copies.Count;
            int customized = copies.Count(x => x.IsCustomized);
            return new GlobalActivityTemplateCopiesSummaryDTO(total, total - customized, customized);
        }
 
        public async Task<GlobalActivityTemplateSyncResultDTO> SyncToTenantTemplatesAsync(string globalTemplateId, string userId, string tenantId)
        {
            var global = await _globalRepo.GetByIdAsync(globalTemplateId);
            var filter = Builders<ActivityTemplate>.Filter.And(
                Builders<ActivityTemplate>.Filter.Eq(x => x.GlobalTemplateId, globalTemplateId),
                Builders<ActivityTemplate>.Filter.Eq(x => x.IsCustomized, false)
            );
            var copies = await _templateRepo.FindAsync(filter);
            int updated = 0;
            foreach (var copy in copies)
            {
                copy.Title = global.Title;
                copy.Description = global.Description;
                copy.Channels = global.Channels;
                copy.Tags = global.Tags;
                copy.Type = global.Type;
                copy.DueInDays = global.DueInDays;
                copy.Frequency = global.Frequency;
                await _templateRepo.UpdateAsync(copy);
                updated++;
            }
 
            // One summary audit entry for the propagation — not one per copy
            var auditLog = AuditLogModel.CreateWithInfo(
                AuditLogCategory.EntityCRUD,
                AuditLogEntityType.GlobalActivityTemplate,
                AuditLogOperationType.BulkUpdate,
                globalTemplateId,
                $"Sync propagation complete. Updated {updated} tenant activity template copies.");
            await _auditLogService.CreateAuditLogAsync(auditLog, userId, tenantId);
 
            return new GlobalActivityTemplateSyncResultDTO(updated);
        }
 
        public async Task<GlobalActivityTemplateDeactivateResultDTO> PropagateDeactivationAsync(string globalTemplateId, string userId, string tenantId)
        {
            var filter = Builders<ActivityTemplate>.Filter.Eq(x => x.GlobalTemplateId, globalTemplateId);
            var copies = await _templateRepo.FindAsync(filter);
            int deactivated = 0;
            int skipped = 0;
            foreach (var copy in copies)
            {
                if (copy.IsCustomized)
                {
                    skipped++;
                    continue;
                }
                copy.IsActive = false;
                await _templateRepo.UpdateAsync(copy);
                deactivated++;
            }
 
            // One summary audit entry — not one per copy
            var auditLog = AuditLogModel.CreateWithInfo(
                AuditLogCategory.EntityCRUD,
                AuditLogEntityType.GlobalActivityTemplate,
                AuditLogOperationType.BulkDelete,
                globalTemplateId,
                $"Deactivation propagation complete. Deactivated {deactivated} copies, skipped {skipped} customized copies.");
            await _auditLogService.CreateAuditLogAsync(auditLog, userId, tenantId);
 
            return new GlobalActivityTemplateDeactivateResultDTO(deactivated, skipped);
        }
 
        public async Task<int> PushToExistingEntitiesAsync(string globalTemplateId, string userId, string tenantId)
        {
            // Implementation: fan-out new template to all existing entities
            // that match the EntitySubType+TriggerEvent but have no copy yet
            // This is complex and entity-type-specific; stub for now
 
            // Audit the push operation when implemented:
            // var auditLog = AuditLogModel.CreateWithInfo(
            //     AuditLogCategory.EntityCRUD,
            //     AuditLogEntityType.GlobalActivityTemplate,
            //     AuditLogOperationType.BulkCreate,
            //     globalTemplateId,
            //     $"Push propagation complete. Created {count} new activity template copies.");
            // await _auditLogService.CreateAuditLogAsync(auditLog, userId, tenantId);
 
            throw new NotImplementedException("Push to existing entities not yet implemented");
        }
    }
}

builder.RegisterType<GlobalActivityTemplateService>()
       .As<IGlobalActivityTemplateService>()
       .InstancePerLifetimeScope();

using Leadmetrics.Api.Shared.Tasks;
 
namespace Leadmetrics.Server.Workers.Tasks
{
    public class GlobalTemplatePropagationTask : TaskMessage
    {
        public GlobalTemplatePropagationTask() : base("global-template-propagation") { }
 
        /// <summary>
        /// "sync"       — edit: push field changes to non-customized copies
        /// "deactivate" — delete: mark all copies inactive
        /// "push"       — new: fan-out template to existing entities
        /// </summary>
        public string OperationType { get; set; }
 
        public string GlobalTemplateId { get; set; }
 
        /// <summary>
        /// ID of the admin user who triggered this operation.
        /// Carried through the queue so the worker can attribute audit log entries
        /// without any HTTP context.
        /// </summary>
        public string InitiatedByUserId { get; set; }
 
        /// <summary>
        /// Admin tenant ID (or "global") used as the tenantId when writing audit logs.
        /// </summary>
        public string InitiatedByTenantId { get; set; }
    }
}

using Leadmetrics.Api.Shared.Tasks;
using Leadmetrics.Feature.Activities.Services;
using Microsoft.Extensions.Logging;
using System;
using System.Threading.Tasks;
 
namespace Leadmetrics.Server.Workers.Handlers
{
    public class GlobalTemplatePropagationHandler : TaskHandlerBase, ITaskHandler
    {
        private readonly IGlobalActivityTemplateService _service;
        private readonly ILogger<GlobalTemplatePropagationHandler> _logger;
 
        public GlobalTemplatePropagationHandler(
            IGlobalActivityTemplateService service,
            ILogger<GlobalTemplatePropagationHandler> logger)
        {
            _service = service;
            _logger = logger;
            // Note: IAuditLogService is called inside GlobalActivityTemplateService,
            // not directly in the handler. The handler passes InitiatedByUserId and
            // InitiatedByTenantId through to the service methods.
        }
 
        public async Task ProcessAsync(TaskMessage message)
        {
            var task = message as GlobalTemplatePropagationTask;
            if (task == null) return;
 
            _logger.LogInformation(
                "GlobalTemplatePropagation starting. TemplateId={TemplateId} Op={Op}",
                task.GlobalTemplateId, task.OperationType);
 
            try
            {
                switch (task.OperationType)
                {
                    case "sync":
                        var syncResult = await _service.SyncToTenantTemplatesAsync(
                            task.GlobalTemplateId, task.InitiatedByUserId, task.InitiatedByTenantId);
                        _logger.LogInformation(
                            "GlobalTemplatePropagation sync complete. TemplateId={Id} Updated={Count}",
                            task.GlobalTemplateId, syncResult.UpdatedCount);
                        break;
 
                    case "deactivate":
                        var deactivateResult = await _service.PropagateDeactivationAsync(
                            task.GlobalTemplateId, task.InitiatedByUserId, task.InitiatedByTenantId);
                        _logger.LogInformation(
                            "GlobalTemplatePropagation deactivate complete. TemplateId={Id} Deactivated={D} SkippedCustomized={S}",
                            task.GlobalTemplateId, deactivateResult.DeactivatedCount, deactivateResult.SkippedCustomizedCount);
                        break;
 
                    case "push":
                        var pushed = await _service.PushToExistingEntitiesAsync(
                            task.GlobalTemplateId, task.InitiatedByUserId, task.InitiatedByTenantId);
                        _logger.LogInformation(
                            "GlobalTemplatePropagation push complete. TemplateId={Id} Pushed={Count}",
                            task.GlobalTemplateId, pushed);
                        break;
 
                    default:
                        _logger.LogWarning(
                            "GlobalTemplatePropagation unknown OperationType={Op}",
                            task.OperationType);
                        break;
                }
            }
            catch (Exception ex)
            {
                _logger.LogError(ex,
                    "GlobalTemplatePropagation failed. TemplateId={Id} Op={Op}",
                    task.GlobalTemplateId, task.OperationType);
                throw;
            }
        }
    }
}

builder.RegisterType<GlobalTemplatePropagationHandler>()
       .Keyed<ITaskHandler>("global-template-propagation")
       .InstancePerLifetimeScope();

var userId = GetLoggedInUserId();
var tenantId = GetLoggedInUserTenantId();
 
await _busClient.SendAsync("global-template-propagation", new GlobalTemplatePropagationTask
{
    GlobalTemplateId = id,
    OperationType = "sync",   // or "deactivate" or "push"
    InitiatedByUserId = userId,
    InitiatedByTenantId = tenantId
});

using Leadmetrics.Api.Shared.Controllers;
using Leadmetrics.Api.Shared.Pagination;
using Leadmetrics.Feature.Activities.DTOs;
using Leadmetrics.Feature.Activities.Models;
using Leadmetrics.Feature.Activities.Services;
using Leadmetrics.Server.Workers.Tasks;
using Leadmetrics.Api.Shared.Bus;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
 
namespace Leadmetrics.Admin.Api.Controllers
{
    [Authorize]
    [ApiController]
    [Route("api/global-activity-templates")]
    public class GlobalActivityTemplatesController : BaseController
    {
        private readonly IGlobalActivityTemplateService _service;
        private readonly IBusClient _busClient;
 
        public GlobalActivityTemplatesController(
            IGlobalActivityTemplateService service,
            IBusClient busClient)
        {
            _service = service;
            _busClient = busClient;
            // Note: audit logging is handled inside GlobalActivityTemplateService.
            // The controller extracts userId + tenantId from JWT/header and passes them
            // to every write method so the service can record who performed the action.
        }
 
        /// <summary>
        /// GET /api/global-activity-templates?page=1&size=20
        /// Search and filter paged list of global templates.
        /// </summary>
        [HttpGet]
        public async Task<IActionResult> SearchAsync(
            [FromQuery] GlobalActivityTemplateFilterDTO filter,
            int page = Paging.DefaultPage,
            int size = Paging.DefaultPageSize)
        {
            return await TryExecuteAsync(async () =>
            {
                ApplyPagingLimits(ref page, ref size);
                var result = await _service.SearchAsync(filter, page, size);
                return result;
            });
        }
 
        /// <summary>
        /// GET /api/global-activity-templates/{id}
        /// Get a single global template by ID.
        /// </summary>
        [HttpGet("{id}")]
        public async Task<IActionResult> GetByIdAsync(string id)
        {
            return await TryExecuteAsync(async () =>
            {
                var result = await _service.GetByIdAsync(id);
                return result;
            });
        }
 
        /// <summary>
        /// GET /api/global-activity-templates/{id}/copies
        /// Preview how many tenant copies exist (impact before sync/deactivate).
        /// </summary>
        [HttpGet("{id}/copies")]
        public async Task<IActionResult> GetCopiesSummaryAsync(string id)
        {
            return await TryExecuteAsync(async () =>
            {
                var result = await _service.GetCopiesSummaryAsync(id);
                return result;
            });
        }
 
        /// <summary>
        /// POST /api/global-activity-templates
        /// Create a new global template (does NOT auto-push to tenants).
        /// Use POST /{id}/push to fan-out when ready.
        /// </summary>
        [HttpPost]
        public async Task<IActionResult> CreateAsync([FromBody] NewGlobalActivityTemplateModel model)
        {
            return await TryExecuteAsync(async () =>
            {
                var userId = GetLoggedInUserId();
                var tenantId = GetLoggedInUserTenantId();
                var result = await _service.CreateAsync(model, userId, tenantId);
                return result;
            });
        }
 
        /// <summary>
        /// PUT /api/global-activity-templates/{id}
        /// Update a global template and enqueue a background "sync" job
        /// to push changes to all non-customized tenant copies.
        /// </summary>
        [HttpPut("{id}")]
        public async Task<IActionResult> UpdateAsync(string id, [FromBody] NewGlobalActivityTemplateModel model)
        {
            return await TryExecuteAsync(async () =>
            {
                var userId = GetLoggedInUserId();
                var tenantId = GetLoggedInUserTenantId();
                await _service.UpdateAsync(id, model, userId, tenantId);
 
                await _busClient.SendAsync("global-template-propagation", new GlobalTemplatePropagationTask
                {
                    GlobalTemplateId = id,
                    OperationType = "sync",
                    InitiatedByUserId = userId,
                    InitiatedByTenantId = tenantId
                });
 
                return new GlobalTemplatePropagationQueuedDTO(id, "sync");
            });
        }
 
        /// <summary>
        /// DELETE /api/global-activity-templates/{id}
        /// Soft-delete (IsActive=false) the global template and enqueue
        /// a background "deactivate" job to deactivate all tenant copies.
        /// Customized copies are skipped.
        /// </summary>
        [HttpDelete("{id}")]
        public async Task<IActionResult> DeleteAsync(string id)
        {
            return await TryExecuteAsync(async () =>
            {
                var userId = GetLoggedInUserId();
                var tenantId = GetLoggedInUserTenantId();
                await _service.DeactivateAsync(id, userId, tenantId);
 
                await _busClient.SendAsync("global-template-propagation", new GlobalTemplatePropagationTask
                {
                    GlobalTemplateId = id,
                    OperationType = "deactivate",
                    InitiatedByUserId = userId,
                    InitiatedByTenantId = tenantId
                });
 
                return new GlobalTemplatePropagationQueuedDTO(id, "deactivate");
            });
        }
 
        /// <summary>
        /// PUT /api/global-activity-templates/{id}/reactivate
        /// Restore a previously deactivated global template.
        /// Does NOT cascade-reactivate tenant copies (use /sync for that).
        /// </summary>
        [HttpPut("{id}/reactivate")]
        public async Task<IActionResult> ReactivateAsync(string id)
        {
            return await TryExecuteAsync(async () =>
            {
                var userId = GetLoggedInUserId();
                var tenantId = GetLoggedInUserTenantId();
                var result = await _service.ReactivateAsync(id, userId, tenantId);
                return result;
            });
        }
 
        /// <summary>
        /// POST /api/global-activity-templates/{id}/sync
        /// Manually re-push global template fields to all non-customized
        /// tenant copies. Runs in background.
        /// </summary>
        [HttpPost("{id}/sync")]
        public async Task<IActionResult> SyncAsync(string id)
        {
            return await TryExecuteAsync(async () =>
            {
                var userId = GetLoggedInUserId();
                var tenantId = GetLoggedInUserTenantId();
 
                await _busClient.SendAsync("global-template-propagation", new GlobalTemplatePropagationTask
                {
                    GlobalTemplateId = id,
                    OperationType = "sync",
                    InitiatedByUserId = userId,
                    InitiatedByTenantId = tenantId
                });
 
                return new GlobalTemplatePropagationQueuedDTO(id, "sync");
            });
        }
 
        /// <summary>
        /// POST /api/global-activity-templates/{id}/push
        /// Fan-out this template to ALL existing entities that match
        /// EntitySubType + TriggerEvent but don't yet have a copy.
        /// Runs in background. Use sparingly — potentially very large batch.
        /// </summary>
        [HttpPost("{id}/push")]
        public async Task<IActionResult> PushAsync(string id)
        {
            return await TryExecuteAsync(async () =>
            {
                var userId = GetLoggedInUserId();
                var tenantId = GetLoggedInUserTenantId();
 
                await _busClient.SendAsync("global-template-propagation", new GlobalTemplatePropagationTask
                {
                    GlobalTemplateId = id,
                    OperationType = "push",
                    InitiatedByUserId = userId,
                    InitiatedByTenantId = tenantId
                });
 
                return new GlobalTemplatePropagationQueuedDTO(id, "push");
            });
        }
    }
}

// In EntitiesDefaultActivitiesHandler.cs
var templates = _helper.GetDefaultActivities(entitySubType, triggerEvent);
// _helper reads from JSON file

// In EntitiesDefaultActivitiesHandler.cs
var templates = await _globalTemplateService.GetByTriggerAsync(entitySubType, triggerEvent);
// Now reads from GlobalActivityTemplates collection

newTemplate.GlobalTemplateId = globalTemplate.Id;
newTemplate.IsCustomized = false;

// Read each of the 10 JSON files
// For each entry, check if a GlobalActivityTemplate already exists
//   matching: Title + EntitySubType + TriggerEvent (idempotent)
// If not found, insert it
// Log counts: inserted, skipped

// For each GlobalActivityTemplate just seeded:
//   Find all ActivityTemplate documents where Title matches
//     AND EntitySubType matches AND GlobalTemplateId is null
//   Set GlobalTemplateId = global.Id, IsCustomized = false
// Log backfill counts per global template

// === GlobalActivityTemplate indexes ===
 
// Primary runtime query: GetByTriggerAsync (called every time an entity is created)
await CreateCompoundIndex<GlobalActivityTemplate>("EntitySubType", "TriggerEvent", "IsActive");
 
// Admin portal search/filter
await CreateIndex<GlobalActivityTemplate>("EntityType");
await CreateIndex<GlobalActivityTemplate>("IsActive");
 
// === ActivityTemplate indexes (new + pre-existing gap) ===
 
// Worker propagation queries: both sync (+ IsCustomized filter) and deactivate
await CreateCompoundIndex<ActivityTemplate>("GlobalTemplateId", "IsCustomized");
 
// Pre-existing gap: every ActivityTemplate query starts with TenantId
await CreateCompoundIndex<ActivityTemplate>("TenantId", "IsActive");

// Single-field ascending index (idempotent — checks before creating)
await CreateIndex<T>("FieldName");
 
// Compound ascending index on N fields
await CreateCompoundIndex<T>("Field1", "Field2", "Field3");

await CreateCompoundIndex<GlobalActivityTemplate>("EntitySubType", "TriggerEvent", "IsActive");
await CreateIndex<GlobalActivityTemplate>("EntityType");
await CreateIndex<GlobalActivityTemplate>("IsActive");

await CreateCompoundIndex<ActivityTemplate>("GlobalTemplateId", "IsCustomized");
await CreateCompoundIndex<ActivityTemplate>("TenantId", "IsActive");

public const string GlobalActivityTemplate = "GlobalActivityTemplate";

// From service method, after the DB write:
var auditLog = AuditLogModel.Create(
    AuditLogCategory.EntityCRUD,
    AuditLogEntityType.GlobalActivityTemplate,
    AuditLogOperationType.Create,       // or Update / Delete
    entity.Id,
    JsonConvert.SerializeObject(entity) // Info field — snapshot of the entity
);
await _auditLogService.CreateAuditLogAsync(auditLog, userId, tenantId);

var auditLog = AuditLogModel.CreateWithInfo(
    AuditLogCategory.EntityCRUD,
    AuditLogEntityType.GlobalActivityTemplate,
    AuditLogOperationType.BulkUpdate,
    globalTemplateId,
    $"Sync propagation complete. Updated {updated} tenant activity template copies."
);
await _auditLogService.CreateAuditLogAsync(auditLog, userId, tenantId);