af6b5b76ef
75 fichiers, ~1 mois de travail depuis f222861 (17/07). Contenu :
Onboarding self-service — jamais exécuté de bout en bout
OnboardingController, StripeWebhookController, StripeService, ResendEmailService
+ IEmailService (10 templates), EmailTemplates/, TrialLifecycleService (Hangfire),
PasswordTokenHelper, SlugHelper, 5 DTOs. Essai 14 j, Stripe customer/Checkout/Tax,
mot de passe oublié + invitation user, plafond IA d'essai.
Schéma Postgres v3 — passe pendant que la base est vide
ContentEmbedding + index HNSW (vector_cosine_ops), IEmbeddingService +
GoogleEmbeddingService (gemini-embedding-001, 768 dims), Deployment/Dockerfile.postgres
(postgis 3.4.3 + pgvector 0.8.6, épinglé par digest — un tag mobile rejouerait le
warning de collation glibc). Colonnes Resource : StoragePath, FileName,
IncludeInAiKnowledge, AiIndexStatus + nouveaux ResourceType ajoutés EN FIN d'enum.
Guide IA
Champs Guide* sur Instance + InstanceDTO, AssistantService lit la configuration client
dans les 4 blocs de prompt (ton codé en dur retiré, règle hors-sujet ajoutée aux deux
variantes qui n'en avaient pas), IHttpClientFactory à la place des new HttpClient().
Table VisitorQuestion + ConversationId sur AiChatRequest.
Stats
Rétention unifiée à 13 mois (instances ET plans), VisitEventPurgeService.
Nettoyage
IsStepLocked / IsHiddenInitially / FactContent supprimés de GuidedStep — IsStepLocked
rendait une étape définitivement infranchissable même après réussite.
SectionMap allégé (-57 lignes).
Tests
SectionParcoursControllerTests, FakeConfiguration, FakeEmailService.
ContentEmbedding a cassé 116 tests sur 124 (EF InMemory ne connaît pas Vector) :
l'entité est exclue quand le provider n'est pas Npgsql. Conséquence assumée —
le vector store n'est couvert par aucun test. dotnet test 124/124.
10 migrations EF. Base locale à jour, dotnet build 0 erreur.
Rien n'est en prod : la bascule Mongo → Postgres est décrite dans DOCS/STATUS.md §1quinquies.
⚠️ appsettings.json contient les clés Stripe (test) et Resend (prod) en clair — à rotationner.
578 lines
25 KiB
C#
578 lines
25 KiB
C#
using Manager.DTOs;
|
|
using ManagerService.Data.SubSection;
|
|
using ManagerService.DTOs;
|
|
using Microsoft.AspNetCore.Http;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Security.Claims;
|
|
using System.Text.Json;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using static ManagerService.Data.SubSection.SectionEvent;
|
|
|
|
namespace ManagerService.Data
|
|
{
|
|
public class MyInfoMateDbContext : DbContext
|
|
{
|
|
/// <summary>
|
|
/// Fenêtre d'historique des statistiques, en jours — 13 mois.
|
|
/// Sert à la fois de valeur seed des plans et de seuil de purge des VisitEvent.
|
|
/// </summary>
|
|
public const int StatsRetentionDays = 395;
|
|
|
|
private readonly IHttpContextAccessor _httpContextAccessor;
|
|
|
|
public MyInfoMateDbContext(DbContextOptions<MyInfoMateDbContext> options, IHttpContextAccessor httpContextAccessor)
|
|
: base(options)
|
|
{
|
|
_httpContextAccessor = httpContextAccessor;
|
|
}
|
|
|
|
public DbSet<Instance> Instances { get; set; }
|
|
public DbSet<SubscriptionPlan> SubscriptionPlans { get; set; }
|
|
public DbSet<Configuration> Configurations { get; set; }
|
|
public DbSet<Section> Sections { get; set; }
|
|
public DbSet<Device> Devices { get; set; }
|
|
public DbSet<Resource> Resources { get; set; }
|
|
public DbSet<User> Users { get; set; }
|
|
|
|
public DbSet<ApplicationInstance> ApplicationInstances { get; set; }
|
|
public DbSet<AppConfigurationLink> AppConfigurationLinks { get; set; }
|
|
|
|
|
|
// MAP
|
|
public DbSet<GeoPoint> GeoPoints { get; set; }
|
|
|
|
// QUIZ
|
|
public DbSet<QuizQuestion> QuizQuestions { get; set; }
|
|
|
|
public DbSet<GuidedPath> GuidedPaths { get; set; }
|
|
public DbSet<GuidedStep> GuidedSteps { get; set; }
|
|
|
|
// Events
|
|
public DbSet<ProgrammeBlock> ProgrammeBlocks { get; set; }
|
|
public DbSet<MapAnnotation> MapAnnotations { get; set; }
|
|
|
|
// Agenda
|
|
public DbSet<EventAgenda> EventAgendas { get; set; }
|
|
|
|
// Statistics
|
|
public DbSet<VisitEvent> VisitEvents { get; set; }
|
|
|
|
// API Keys
|
|
public DbSet<ApiKey> ApiKeys { get; set; }
|
|
|
|
// Push Notifications
|
|
public DbSet<PushNotification> PushNotifications { get; set; }
|
|
|
|
// Audit
|
|
public DbSet<AuditLog> AuditLogs { get; set; }
|
|
|
|
// Guide IA — recherche sémantique
|
|
public DbSet<ContentEmbedding> ContentEmbeddings { get; set; }
|
|
|
|
// Guide IA — journal des questions visiteurs
|
|
public DbSet<VisitorQuestion> VisitorQuestions { get; set; }
|
|
|
|
public override int SaveChanges(bool acceptAllChangesOnSuccess)
|
|
{
|
|
StampAuditableEntities();
|
|
var auditEntries = BuildAuditEntries();
|
|
var result = base.SaveChanges(acceptAllChangesOnSuccess);
|
|
if (auditEntries.Any())
|
|
base.SaveChanges(acceptAllChangesOnSuccess);
|
|
return result;
|
|
}
|
|
|
|
public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
|
|
{
|
|
StampAuditableEntities();
|
|
var auditEntries = BuildAuditEntries();
|
|
var result = await base.SaveChangesAsync(cancellationToken);
|
|
if (auditEntries.Any())
|
|
await base.SaveChangesAsync(cancellationToken);
|
|
return result;
|
|
}
|
|
|
|
private void StampAuditableEntities()
|
|
{
|
|
var now = DateTime.UtcNow;
|
|
foreach (var entry in ChangeTracker.Entries<IAuditableEntity>())
|
|
{
|
|
if (entry.State == EntityState.Added)
|
|
entry.Entity.DateCreation = now;
|
|
if (entry.State is EntityState.Added or EntityState.Modified)
|
|
entry.Entity.DateUpdate = now;
|
|
}
|
|
}
|
|
|
|
private static readonly HashSet<Type> AuditedTypes = new()
|
|
{
|
|
typeof(Section), typeof(Resource), typeof(Configuration),
|
|
typeof(Device), typeof(User), typeof(Instance)
|
|
};
|
|
|
|
private List<AuditLog> BuildAuditEntries()
|
|
{
|
|
var userId = _httpContextAccessor?.HttpContext?.User?.FindFirstValue(ClaimTypes.NameIdentifier);
|
|
var entries = new List<AuditLog>();
|
|
|
|
// Matérialisé avant la boucle : ajouter un AuditLog au contexte modifie le
|
|
// ChangeTracker, ce qui invaliderait l'énumération en cours
|
|
// ("Collection was modified"). Les logs sont donc ajoutés après la boucle.
|
|
var auditedEntries = ChangeTracker.Entries()
|
|
.Where(e => AuditedTypes.Contains(e.Entity.GetType())
|
|
&& e.State is EntityState.Added or EntityState.Modified or EntityState.Deleted)
|
|
.ToList();
|
|
|
|
foreach (var entry in auditedEntries)
|
|
{
|
|
var action = entry.State switch
|
|
{
|
|
EntityState.Added => "Create",
|
|
EntityState.Modified => "Update",
|
|
EntityState.Deleted => "Delete",
|
|
_ => null
|
|
};
|
|
|
|
var entityId = entry.Properties
|
|
.FirstOrDefault(p => p.Metadata.IsPrimaryKey())?.CurrentValue?.ToString();
|
|
|
|
var instanceId = entry.Properties
|
|
.FirstOrDefault(p => p.Metadata.Name == "InstanceId")?.CurrentValue?.ToString();
|
|
|
|
string? oldValues = null;
|
|
string? newValues = null;
|
|
|
|
if (entry.State == EntityState.Modified)
|
|
{
|
|
oldValues = JsonSerializer.Serialize(
|
|
entry.Properties.Where(p => p.IsModified)
|
|
.ToDictionary(p => p.Metadata.Name, p => p.OriginalValue));
|
|
newValues = JsonSerializer.Serialize(
|
|
entry.Properties.Where(p => p.IsModified)
|
|
.ToDictionary(p => p.Metadata.Name, p => p.CurrentValue));
|
|
}
|
|
else if (entry.State == EntityState.Added)
|
|
{
|
|
newValues = JsonSerializer.Serialize(
|
|
entry.Properties.ToDictionary(p => p.Metadata.Name, p => p.CurrentValue));
|
|
}
|
|
|
|
var log = new AuditLog
|
|
{
|
|
EntityType = entry.Entity.GetType().Name,
|
|
EntityId = entityId ?? "",
|
|
Action = action!,
|
|
UserId = userId,
|
|
InstanceId = instanceId,
|
|
OldValues = oldValues,
|
|
NewValues = newValues
|
|
};
|
|
|
|
entries.Add(log);
|
|
}
|
|
|
|
if (entries.Count > 0)
|
|
AuditLogs.AddRange(entries);
|
|
|
|
return entries;
|
|
}
|
|
|
|
protected override void OnModelCreating(ModelBuilder modelBuilder)
|
|
{
|
|
var options = new JsonSerializerOptions
|
|
{
|
|
PropertyNameCaseInsensitive = true
|
|
};
|
|
|
|
base.OnModelCreating(modelBuilder);
|
|
|
|
// Les types suivants sont utilisés uniquement comme valeurs JSONB, pas comme entités DB.
|
|
// Le provider InMemory les découvre par convention et échoue à la validation
|
|
// si aucune clé primaire n'est définie. On les exclut explicitement.
|
|
modelBuilder.Ignore<ContentDTO>();
|
|
modelBuilder.Ignore<ResponseDTO>();
|
|
modelBuilder.Ignore<CategorieDTO>();
|
|
modelBuilder.Ignore<TranslationDTO>();
|
|
modelBuilder.Ignore<TranslationAndResourceDTO>();
|
|
modelBuilder.Ignore<OrderedTranslationAndResourceDTO>();
|
|
modelBuilder.Ignore<EventAddress>();
|
|
modelBuilder.Ignore<Translation>();
|
|
modelBuilder.Ignore<TranslationAndResource>();
|
|
modelBuilder.Ignore<OrderedTranslationAndResource>();
|
|
|
|
modelBuilder.Entity<Configuration>()
|
|
.Property(s => s.Title)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<Instance>()
|
|
.Property(i => i.GuideFallbackMessages)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
// Guide IA — recherche sémantique.
|
|
// Le type vector n'existe que sur Npgsql : les tests tournent sur EF InMemory,
|
|
// qui échoue à la validation du modèle s'il rencontre une propriété Vector.
|
|
// L'entité y est donc exclue — elle n'a de sens que face à une vraie base.
|
|
if (!Database.IsNpgsql())
|
|
{
|
|
modelBuilder.Ignore<ContentEmbedding>();
|
|
}
|
|
else
|
|
{
|
|
// L'extension est déclarée ici pour que la migration la crée : aucun
|
|
// CREATE EXTENSION à lancer à la main sur dev, preprod ou prod.
|
|
modelBuilder.HasPostgresExtension("vector");
|
|
|
|
modelBuilder.Entity<ContentEmbedding>(entity =>
|
|
{
|
|
entity.Property(e => e.Embedding)
|
|
.HasColumnType($"vector({ContentEmbedding.Dimensions})")
|
|
.IsRequired();
|
|
|
|
// Le projet n'active pas les reference types nullable : sans IsRequired()
|
|
// explicite, EF génère tout en nullable — y compris InstanceId, qui porte
|
|
// la séparation entre deux clients.
|
|
entity.Property(e => e.InstanceId).IsRequired();
|
|
entity.Property(e => e.ContentId).IsRequired();
|
|
entity.Property(e => e.Text).IsRequired();
|
|
entity.Property(e => e.Language).HasMaxLength(5).IsRequired();
|
|
|
|
// Recherche par similarité cosinus.
|
|
entity.HasIndex(e => e.Embedding)
|
|
.HasMethod("hnsw")
|
|
.HasOperators("vector_cosine_ops");
|
|
|
|
// Filtre appliqué à chaque recherche.
|
|
entity.HasIndex(e => new { e.InstanceId, e.ContentType });
|
|
|
|
// Hangfire rejoue les jobs (retry, redémarrage de conteneur). Sans cette
|
|
// contrainte, un second passage dupliquerait silencieusement les morceaux,
|
|
// qui remonteraient ensuite deux fois dans chaque réponse du guide.
|
|
entity.HasIndex(e => new { e.ContentType, e.ContentId, e.ChunkIndex })
|
|
.IsUnique();
|
|
});
|
|
}
|
|
|
|
modelBuilder.Entity<VisitorQuestion>(entity =>
|
|
{
|
|
entity.Property(e => e.CitedContentIds)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<string>>(v, options));
|
|
|
|
entity.Property(e => e.Language).HasMaxLength(5);
|
|
|
|
// Volume par période et questions sans réponse du mois.
|
|
entity.HasIndex(e => new { e.InstanceId, e.CreatedAt });
|
|
|
|
// Reconstitution d'une conversation, et purge à 90 jours.
|
|
entity.HasIndex(e => e.ConversationId);
|
|
});
|
|
|
|
modelBuilder.Entity<Section>()
|
|
.Property<string>("Discriminator")
|
|
.HasMaxLength(50);
|
|
|
|
modelBuilder.Entity<Section>()
|
|
.HasDiscriminator<string>("Discriminator")
|
|
.HasValue<Section>("Base")
|
|
.HasValue<SectionAgenda>("Agenda")
|
|
.HasValue<SectionArticle>("Article")
|
|
.HasValue<SectionEvent>("Event")
|
|
.HasValue<SectionMap>("Map")
|
|
.HasValue<SectionMenu>("Menu")
|
|
.HasValue<SectionPdf>("PDF")
|
|
.HasValue<SectionGame>("Game")
|
|
.HasValue<SectionQuiz>("Quiz")
|
|
.HasValue<SectionSlider>("Slider")
|
|
.HasValue<SectionVideo>("Video")
|
|
.HasValue<SectionWeather>("Weather")
|
|
.HasValue<SectionWeb>("Web")
|
|
.HasValue<SectionParcours>("Parcours");
|
|
|
|
/*modelBuilder.Entity<GeoPoint>(entity =>
|
|
{
|
|
entity.Property(e => e.Geometry).HasColumnType("geometry");
|
|
});
|
|
|
|
modelBuilder.Entity<GuidedStep>(entity =>
|
|
{
|
|
entity.Property(e => e.Geometry).HasColumnType("geometry");
|
|
});*/
|
|
|
|
modelBuilder.Entity<Section>()
|
|
.Property(s => s.Title)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<Section>()
|
|
.Property(s => s.Description)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<GeoPoint>()
|
|
.Property(s => s.Title)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<GeoPoint>()
|
|
.Property(s => s.Description)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<GeoPoint>()
|
|
.Property(s => s.Contents)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<ContentDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<GeoPoint>()
|
|
.Property(s => s.Schedules)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<GeoPoint>()
|
|
.Property(s => s.Prices)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<GeoPoint>()
|
|
.Property(s => s.Phone)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<GeoPoint>()
|
|
.Property(s => s.Email)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<GeoPoint>()
|
|
.Property(s => s.Site)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
// Configurations JSON pour GuidedPath
|
|
modelBuilder.Entity<GuidedPath>()
|
|
.Property(gp => gp.Title)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<GuidedPath>()
|
|
.Property(gp => gp.Description)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<GuidedPath>()
|
|
.Property(gp => gp.GameMessageDebut)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationAndResourceDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<GuidedPath>()
|
|
.Property(gp => gp.GameMessageFin)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationAndResourceDTO>>(v, options));
|
|
|
|
// Configurations JSON pour GuidedStep
|
|
modelBuilder.Entity<GuidedStep>()
|
|
.Property(gs => gs.Title)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<GuidedStep>()
|
|
.Property(gs => gs.Description)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<GuidedStep>()
|
|
.Property(gp => gp.TimerExpiredMessage)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<GuidedStep>()
|
|
.Property(gs => gs.AudioIds)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<GuidedStep>()
|
|
.Property(gs => gs.Contents)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<ContentDTO>>(v, options));
|
|
|
|
// SectionParcours: lien optionnel vers une SectionMap de base
|
|
modelBuilder.Entity<SectionParcours>()
|
|
.HasOne(sp => sp.BaseMap)
|
|
.WithMany()
|
|
.HasForeignKey(sp => sp.BaseSectionMapId)
|
|
.IsRequired(false)
|
|
.OnDelete(DeleteBehavior.SetNull);
|
|
|
|
// GuidedPath: lien vers SectionParcours
|
|
modelBuilder.Entity<GuidedPath>()
|
|
.HasOne(gp => gp.SectionParcours)
|
|
.WithMany(sp => sp.GuidedPaths)
|
|
.HasForeignKey(gp => gp.SectionParcoursId)
|
|
.IsRequired(false)
|
|
.OnDelete(DeleteBehavior.Cascade);
|
|
|
|
modelBuilder.Entity<EventAgenda>()
|
|
.Property(s => s.Label)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<EventAgenda>()
|
|
.Property(s => s.Description)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<List<TranslationDTO>>(v, options));
|
|
|
|
modelBuilder.Entity<EventAgenda>()
|
|
.Property(s => s.Address)
|
|
.HasColumnType("jsonb")
|
|
.HasConversion(
|
|
v => JsonSerializer.Serialize(v, options),
|
|
v => JsonSerializer.Deserialize<EventAddress>(v, options));
|
|
|
|
// SectionEvent: link to base SectionMap
|
|
modelBuilder.Entity<SectionEvent>()
|
|
.HasOne(se => se.BaseMap)
|
|
.WithMany()
|
|
.HasForeignKey(se => se.BaseSectionMapId)
|
|
.IsRequired(false)
|
|
.OnDelete(DeleteBehavior.SetNull);
|
|
|
|
// MapAnnotation: global event-level annotations linked directly to SectionEvent
|
|
modelBuilder.Entity<MapAnnotation>()
|
|
.HasOne<SectionEvent>()
|
|
.WithMany(se => se.GlobalMapAnnotations)
|
|
.HasForeignKey(ma => ma.SectionEventId)
|
|
.IsRequired(false)
|
|
.OnDelete(DeleteBehavior.Cascade);
|
|
|
|
// Ces colonnes ont un defaultValue dans la migration, ce qui amène EF Core à les traiter
|
|
// comme ValueGeneratedOnAdd (read-only après insert). On force ValueGeneratedNever.
|
|
modelBuilder.Entity<Instance>()
|
|
.Property(i => i.StorageQuotaBytes).ValueGeneratedNever();
|
|
modelBuilder.Entity<Instance>()
|
|
.Property(i => i.AiTokensPerMonth).ValueGeneratedNever();
|
|
modelBuilder.Entity<Instance>()
|
|
.Property(i => i.HasStats).ValueGeneratedNever();
|
|
modelBuilder.Entity<Instance>()
|
|
.Property(i => i.StatsHistoryDays).ValueGeneratedNever();
|
|
modelBuilder.Entity<Instance>()
|
|
.Property(i => i.HasAdvancedStats).ValueGeneratedNever();
|
|
modelBuilder.Entity<Instance>()
|
|
.Property(i => i.IsActive).ValueGeneratedNever();
|
|
modelBuilder.Entity<Instance>()
|
|
.Property(i => i.IsTrialActive).ValueGeneratedNever();
|
|
modelBuilder.Entity<Instance>()
|
|
.Property(i => i.TrialAiTokensUsed).ValueGeneratedNever();
|
|
modelBuilder.Entity<Instance>()
|
|
.Property(i => i.TrialCheckInEmailSent).ValueGeneratedNever();
|
|
modelBuilder.Entity<Instance>()
|
|
.Property(i => i.TrialReminderEmailSent).ValueGeneratedNever();
|
|
modelBuilder.Entity<Instance>()
|
|
.Property(i => i.TrialLastDayEmailSent).ValueGeneratedNever();
|
|
|
|
// Fenêtre d'historique lisible, identique pour tous les plans qui ont les stats.
|
|
// 13 mois : un dossier de subside est annuel, et il faut pouvoir comparer au même
|
|
// mois de l'année précédente. La différenciation commerciale se fait sur la
|
|
// profondeur (HasAdvancedStats), pas sur la durée — décidé le 2026-08-09.
|
|
// Au-delà, les VisitEvent sont purgés (job `visit-events-purge`).
|
|
|
|
// Seed : plans d'abonnement par défaut
|
|
modelBuilder.Entity<SubscriptionPlan>().HasData(
|
|
new SubscriptionPlan
|
|
{
|
|
Id = "plan-starter",
|
|
Name = "Starter",
|
|
StorageQuotaBytes = 1L * 1024 * 1024 * 1024, // 1 GB
|
|
AiTokensPerMonth = 0,
|
|
HasStats = false,
|
|
StatsHistoryDays = 30,
|
|
HasAdvancedStats = false,
|
|
},
|
|
new SubscriptionPlan
|
|
{
|
|
Id = "plan-standard",
|
|
Name = "Standard",
|
|
StorageQuotaBytes = 10L * 1024 * 1024 * 1024, // 10 GB
|
|
AiTokensPerMonth = 5_000_000, // ~500 req/mois * ~10k tokens/req estimés, à ajuster selon l'usage réel observé
|
|
HasStats = true,
|
|
StatsHistoryDays = StatsRetentionDays,
|
|
HasAdvancedStats = false,
|
|
},
|
|
new SubscriptionPlan
|
|
{
|
|
Id = "plan-premium",
|
|
Name = "Premium",
|
|
StorageQuotaBytes = 50L * 1024 * 1024 * 1024, // 50 GB
|
|
AiTokensPerMonth = 20_000_000, // ~2000 req/mois * ~10k tokens/req estimés, à ajuster selon l'usage réel observé
|
|
HasStats = true,
|
|
StatsHistoryDays = StatsRetentionDays,
|
|
HasAdvancedStats = true,
|
|
},
|
|
new SubscriptionPlan
|
|
{
|
|
Id = "plan-essentiel",
|
|
Name = "Essentiel",
|
|
StorageQuotaBytes = 1L * 1024 * 1024 * 1024, // 1 GB
|
|
AiTokensPerMonth = 500_000, // ~50 req/mois * ~10k tokens/req estimés — IA reste surtout un add-on payant sur ce plan
|
|
HasStats = true,
|
|
StatsHistoryDays = StatsRetentionDays,
|
|
HasAdvancedStats = false,
|
|
}
|
|
);
|
|
}
|
|
}
|
|
}
|