diff --git a/src/PostIt/PostIt.Tests/HomePageProviderFlowTests.cs b/src/PostIt/PostIt.Tests/HomePageProviderFlowTests.cs
index 16f01c5e9..accd22ded 100644
--- a/src/PostIt/PostIt.Tests/HomePageProviderFlowTests.cs
+++ b/src/PostIt/PostIt.Tests/HomePageProviderFlowTests.cs
@@ -12,4 +12,68 @@ public class HomePageProviderFlowTests
         Assert.NotNull(vm.OpenProviderRequests);
         Assert.True(vm.OpenProviderRequests.CanExecute(null));
     }
+
+    [Fact]
+    public void HomePage_exposes_profile_command()
+    {
+        var vm = new HomePageViewModel();
+
+        Assert.NotNull(vm.OpenProfile);
+        Assert.True(vm.OpenProfile.CanExecute(null));
+    }
+
+    [Fact]
+    public void HomePage_exposes_performer_configuration_command()
+    {
+        var vm = new HomePageViewModel();
+
+        Assert.NotNull(vm.OpenPerformerConfiguration);
+        Assert.True(vm.OpenPerformerConfiguration.CanExecute(null));
+    }
+
+    [Fact]
+    public void HomePage_exposes_administration_command()
+    {
+        var vm = new HomePageViewModel();
+
+        Assert.NotNull(vm.OpenAdministration);
+        Assert.True(vm.OpenAdministration.CanExecute(null));
+    }
+
+    [Fact]
+    public void Administration_page_filters_users_by_search_text()
+    {
+        var vm = new AdministrationPageViewModel();
+        vm.Users.Add(new Yavsc.Abstract.Identity.UserInfo { UserId = "1", UserName = "alice" });
+        vm.Users.Add(new Yavsc.Abstract.Identity.UserInfo { UserId = "2", UserName = "bob" });
+        vm.Users.Add(new Yavsc.Abstract.Identity.UserInfo { UserId = "3", UserName = "carol" });
+
+        vm.SearchText = "ali";
+
+        Assert.Single(vm.FilteredUsers);
+        Assert.Equal("alice", vm.FilteredUsers[0].UserName);
+    }
+
+    [Fact]
+    public void UserProfilePage_exposes_full_name_and_address_fields()
+    {
+        var vm = new UserProfilePageViewModel();
+
+        Assert.Equal("—", vm.FullName);
+        Assert.Equal("—", vm.Address);
+        Assert.NotNull(vm.RefreshCommand);
+    }
+
+    [Fact]
+    public void UserProfilePage_can_save_profile_values()
+    {
+        var vm = new UserProfilePageViewModel
+        {
+            FullName = "Alice Example",
+            Address = "14 rue de l’Érable"
+        };
+
+        Assert.NotNull(vm.SaveProfileCommand);
+        Assert.True(vm.SaveProfileCommand.CanExecute(null));
+    }
 }
diff --git a/src/PostIt/PostIt.Tests/ResourceUsageApiClientTests.cs b/src/PostIt/PostIt.Tests/ResourceUsageApiClientTests.cs
new file mode 100644
index 000000000..407183b77
--- /dev/null
+++ b/src/PostIt/PostIt.Tests/ResourceUsageApiClientTests.cs
@@ -0,0 +1,117 @@
+using System.Net.Http;
+using System.Text.Json;
+using Yavsc.Abstract.Resources;
+using Yavsc.Api.Client;
+
+namespace PostIt.Tests;
+
+public class ResourceUsageApiClientTests
+{
+    [Fact]
+    public async Task GetCurrentAsync_calls_user_usage_endpoint()
+    {
+        var fake = new FakeYavscApiClient();
+        var client = new ResourceUsageApiClient(fake, "https://example.invalid/api/v1/");
+
+        var usage = await client.GetCurrentAsync();
+
+        Assert.Equal("https://example.invalid/api/v1/resource-usage/me", fake.LastPath);
+        Assert.Equal("GET", fake.LastMethod);
+        Assert.Equal(12.5m, usage.ApiCalls);
+        Assert.Equal(3.2m, usage.CpuSeconds);
+    }
+
+    [Fact]
+    public async Task GetAdminOverviewAsync_calls_admin_usage_endpoint()
+    {
+        var fake = new FakeYavscApiClient();
+        var client = new ResourceUsageApiClient(fake, "https://example.invalid/api/v1/");
+
+        var usage = await client.GetAdminOverviewAsync();
+
+        Assert.Equal("https://example.invalid/api/v1/resource-usage/admin", fake.LastPath);
+        Assert.Equal("GET", fake.LastMethod);
+        Assert.Equal(2, usage.Count);
+        Assert.Equal("administrator", usage[0].UserName);
+    }
+
+    private sealed class FakeYavscApiClient : IYavscApiClient
+    {
+        public HttpClient Http { get; } = new();
+        public string? LastPath { get; private set; }
+        public string? LastMethod { get; private set; }
+
+        public Task<T> CallAsync<T>(HttpMethod method, string path, object? body = null, CancellationToken ct = default)
+        {
+            LastMethod = method.Method;
+            LastPath = path;
+
+            if (typeof(T) == typeof(ResourceUsageSummary))
+            {
+                var summary = new ResourceUsageSummary
+                {
+                    UserId = "user-42",
+                    UserName = "alice",
+                    ApiCalls = 12.5m,
+                    CpuSeconds = 3.2m,
+                    BandwidthMb = 18.4m,
+                    StorageMb = 51.2m,
+                    EstimatedCompensation = 4.9m,
+                    Currency = "EUR",
+                    RecordedAtUtc = DateTimeOffset.UtcNow
+                };
+
+                return Task.FromResult((T)(object)summary);
+            }
+
+            if (typeof(T) == typeof(List<ResourceUsageSummary>))
+            {
+                var list = new List<ResourceUsageSummary>
+                {
+                    new()
+                    {
+                        UserId = "admin-user",
+                        UserName = "administrator",
+                        ApiCalls = 90m,
+                        CpuSeconds = 14m,
+                        BandwidthMb = 500m,
+                        StorageMb = 2048m,
+                        EstimatedCompensation = 32m,
+                        Currency = "EUR",
+                        RecordedAtUtc = DateTimeOffset.UtcNow
+                    },
+                    new()
+                    {
+                        UserId = "user-99",
+                        UserName = "bob",
+                        ApiCalls = 40m,
+                        CpuSeconds = 7m,
+                        BandwidthMb = 120m,
+                        StorageMb = 600m,
+                        EstimatedCompensation = 15m,
+                        Currency = "EUR",
+                        RecordedAtUtc = DateTimeOffset.UtcNow
+                    }
+                };
+
+                return Task.FromResult((T)(object)list);
+            }
+
+            throw new NotSupportedException($"Unsupported type: {typeof(T).FullName}");
+        }
+
+        public Task<T> CallAsync<T>(HttpMethod method, string path, Func<HttpContent> contentFactory, CancellationToken ct = default)
+            => throw new NotSupportedException();
+
+        public Task CallAsync(HttpMethod method, string path, object? body = null, CancellationToken ct = default)
+            => Task.CompletedTask;
+
+        public Task CallAsync(HttpMethod method, string path, Func<HttpContent> contentFactory, CancellationToken ct = default)
+            => Task.CompletedTask;
+
+        public Task<byte[]> DownloadAsync(HttpMethod method, string path, CancellationToken ct = default)
+            => Task.FromResult(Array.Empty<byte>());
+
+        public ValueTask DisposeAsync() => ValueTask.CompletedTask;
+    }
+}
diff --git a/src/PostIt/PostIt/Helpers/ServiceCollectionHelpers.cs b/src/PostIt/PostIt/Helpers/ServiceCollectionHelpers.cs
index 3d135987b..22885aca8 100644
--- a/src/PostIt/PostIt/Helpers/ServiceCollectionHelpers.cs
+++ b/src/PostIt/PostIt/Helpers/ServiceCollectionHelpers.cs
@@ -76,6 +76,9 @@ public static class ServiceCollectionHelpers
         services.AddTransient<EstimateListPage>();
         services.AddTransient<EstimateValidationPage>();
         services.AddTransient<MyFilesPage>();
+        services.AddTransient<UserProfilePage>();
+        services.AddTransient<PerformerConfigurationPage>();
+        services.AddTransient<AdministrationPage>();
         services.AddTransient<ResourceUsagePage>();
 
         // ViewModels
@@ -95,6 +98,9 @@ public static class ServiceCollectionHelpers
         services.AddSingleton<IUserDirectory>(userDirectory);
         services.AddSingleton<AboutPageViewModel>();
         services.AddSingleton<HomePageViewModel>();
+        services.AddTransient<UserProfilePageViewModel>();
+        services.AddTransient<PerformerConfigurationPageViewModel>();
+        services.AddTransient<AdministrationPageViewModel>();
         services.AddSingleton<SignaturePageViewModel>();
         services.AddSingleton<CirclesPageViewModel>();
         services.AddSingleton<ActivitiesPageViewModel>();
diff --git a/src/PostIt/PostIt/ViewLocator.cs b/src/PostIt/PostIt/ViewLocator.cs
index 01ecb0c25..986ddc92f 100644
--- a/src/PostIt/PostIt/ViewLocator.cs
+++ b/src/PostIt/PostIt/ViewLocator.cs
@@ -60,6 +60,9 @@ public class ViewLocator : IDataTemplate
             EstimateListPageViewModel => services.GetRequiredService<EstimateListPage>(),
             EstimateValidationPageViewModel => services.GetRequiredService<EstimateValidationPage>(),
             MyFilesViewModel => services.GetRequiredService<MyFilesPage>(),
+            UserProfilePageViewModel => services.GetRequiredService<UserProfilePage>(),
+            PerformerConfigurationPageViewModel => services.GetRequiredService<PerformerConfigurationPage>(),
+            AdministrationPageViewModel => services.GetRequiredService<AdministrationPage>(),
             ResourceUsagePageViewModel => services.GetRequiredService<ResourceUsagePage>(),
             ChatViewModel => services.GetRequiredService<ChatPage>(),
             null => new TextBlock { Text = "No view for <null>" },
diff --git a/src/PostIt/PostIt/ViewModels/AdministrationPageViewModel.cs b/src/PostIt/PostIt/ViewModels/AdministrationPageViewModel.cs
new file mode 100644
index 000000000..596064aa7
--- /dev/null
+++ b/src/PostIt/PostIt/ViewModels/AdministrationPageViewModel.cs
@@ -0,0 +1,95 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Net.Http;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using PostIt.Services;
+using Yavsc.Abstract.Identity;
+
+namespace PostIt.ViewModels;
+
+public partial class AdministrationPageViewModel : ViewModelBase
+{
+    private readonly YavscApiClient? _api;
+
+    [ObservableProperty]
+    public partial bool IsBusy { get; set; }
+
+    [ObservableProperty]
+    public partial ObservableCollection<UserInfo> Users { get; set; } = new();
+
+    [ObservableProperty]
+    public partial string SearchText { get; set; } = string.Empty;
+
+    [ObservableProperty]
+    public partial string StatusMessage { get; set; } = "Chargement…";
+
+    public IReadOnlyList<UserInfo> FilteredUsers =>
+        string.IsNullOrWhiteSpace(SearchText)
+            ? Users.ToList()
+            : Users.Where(user =>
+                    (user.UserName ?? string.Empty).Contains(SearchText, StringComparison.OrdinalIgnoreCase)
+                 || (user.Email ?? string.Empty).Contains(SearchText, StringComparison.OrdinalIgnoreCase)
+                 || (user.UserId ?? string.Empty).Contains(SearchText, StringComparison.OrdinalIgnoreCase))
+                .ToList();
+
+    public override bool CanNavigateNext { get => false; protected set { _ = value; } }
+    public override bool CanNavigatePrevious { get => true; protected set { _ = value; } }
+
+    public AdministrationPageViewModel(YavscApiClient? api)
+    {
+        _api = api;
+    }
+
+    public AdministrationPageViewModel() : this(null) { }
+
+    public Task InitializeAsync() => RefreshAsync();
+
+    partial void OnSearchTextChanged(string value)
+    {
+        OnPropertyChanged(nameof(FilteredUsers));
+    }
+
+    [RelayCommand]
+    public async Task RefreshAsync()
+    {
+        if (_api is null)
+        {
+            StatusMessage = "Client API d’administration indisponible.";
+            return;
+        }
+
+        IsBusy = true;
+        try
+        {
+            var query = SearchText.Trim();
+            var usersEndpoint = string.IsNullOrWhiteSpace(query)
+                ? new Uri(new Uri(_api.Settings.ApiUrl.TrimEnd('/') + "/", UriKind.Absolute), "users").ToString()
+                : new Uri(new Uri(_api.Settings.ApiUrl.TrimEnd('/') + "/", UriKind.Absolute), $"users/search/{Uri.EscapeDataString(query)}").ToString();
+
+            var users = await _api.CallAsync<List<UserInfo>>(HttpMethod.Get, usersEndpoint).ConfigureAwait(true);
+
+            Users.Clear();
+            foreach (var user in users ?? [])
+            {
+                Users.Add(user);
+            }
+
+            OnPropertyChanged(nameof(FilteredUsers));
+            StatusMessage = Users.Count > 0 ? $"{Users.Count} utilisateur(s) chargé(s)." : "Aucun utilisateur trouvé.";
+        }
+        catch (Exception ex)
+        {
+            Users.Clear();
+            OnPropertyChanged(nameof(FilteredUsers));
+            StatusMessage = $"Accès administration refusé ou indisponible : {ex.Message}";
+        }
+        finally
+        {
+            IsBusy = false;
+        }
+    }
+}
diff --git a/src/PostIt/PostIt/ViewModels/Layout/HomePageViewModel.cs b/src/PostIt/PostIt/ViewModels/Layout/HomePageViewModel.cs
index 56a3979e0..6a29afbc6 100644
--- a/src/PostIt/PostIt/ViewModels/Layout/HomePageViewModel.cs
+++ b/src/PostIt/PostIt/ViewModels/Layout/HomePageViewModel.cs
@@ -36,6 +36,9 @@ public class HomePageViewModel : ViewModelBase
         OpenProviderEstimates = new AsyncRelayCommand(() => OpenEstimateListAsync(EstimateListPerspective.Provider));
         OpenBlogs = new AsyncRelayCommand(App.PushBlogsPageAsync);
         OpenMyFiles = new AsyncRelayCommand(OpenMyFilesAsync);
+        OpenProfile = new AsyncRelayCommand(OpenProfileAsync);
+        OpenPerformerConfiguration = new AsyncRelayCommand(OpenPerformerConfigurationAsync);
+        OpenAdministration = new AsyncRelayCommand(OpenAdministrationAsync);
         OpenResourceUsage = new AsyncRelayCommand(OpenResourceUsageAsync);
         OpenChat = new AsyncRelayCommand(OpenChatAsync);
     }
@@ -43,6 +46,9 @@ public class HomePageViewModel : ViewModelBase
 
     public IAsyncRelayCommand OpenChat { get; }
     public IAsyncRelayCommand OpenBlogs { get; }
+    public IAsyncRelayCommand OpenProfile { get; }
+    public IAsyncRelayCommand OpenPerformerConfiguration { get; }
+    public IAsyncRelayCommand OpenAdministration { get; }
     public IAsyncRelayCommand OpenResourceUsage { get; }
     public IAsyncRelayCommand OpenActivities { get; }
     public IAsyncRelayCommand OpenProviderRequests { get; }
@@ -140,6 +146,60 @@ public class HomePageViewModel : ViewModelBase
         await app.PushPageAsync(vm);
     }
 
+    private async Task OpenProfileAsync()
+    {
+        var app = (App?)Application.Current;
+        if (app is null)
+        {
+            throw new InvalidOperationException("Application PostIt indisponible.");
+        }
+
+        var vm = app.ServiceProvider?.GetRequiredService<UserProfilePageViewModel>();
+        if (vm is null)
+        {
+            throw new InvalidOperationException("Page profil indisponible.");
+        }
+
+        await vm.InitializeAsync();
+        await app.PushPageAsync(vm);
+    }
+
+    private async Task OpenPerformerConfigurationAsync()
+    {
+        var app = (App?)Application.Current;
+        if (app is null)
+        {
+            throw new InvalidOperationException("Application PostIt indisponible.");
+        }
+
+        var vm = app.ServiceProvider?.GetRequiredService<PerformerConfigurationPageViewModel>();
+        if (vm is null)
+        {
+            throw new InvalidOperationException("Page performer indisponible.");
+        }
+
+        await vm.InitializeAsync();
+        await app.PushPageAsync(vm);
+    }
+
+    private async Task OpenAdministrationAsync()
+    {
+        var app = (App?)Application.Current;
+        if (app is null)
+        {
+            throw new InvalidOperationException("Application PostIt indisponible.");
+        }
+
+        var vm = app.ServiceProvider?.GetRequiredService<AdministrationPageViewModel>();
+        if (vm is null)
+        {
+            throw new InvalidOperationException("Page administration indisponible.");
+        }
+
+        await vm.InitializeAsync();
+        await app.PushPageAsync(vm);
+    }
+
     private async Task OpenResourceUsageAsync()
     {
         var app = (App?)Application.Current;
diff --git a/src/PostIt/PostIt/ViewModels/Layout/UserProfilePageViewModel.cs b/src/PostIt/PostIt/ViewModels/Layout/UserProfilePageViewModel.cs
new file mode 100644
index 000000000..c47fe8b71
--- /dev/null
+++ b/src/PostIt/PostIt/ViewModels/Layout/UserProfilePageViewModel.cs
@@ -0,0 +1,125 @@
+using System;
+using System.Net.Http;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using PostIt.Services;
+using Yavsc.Abstract.Identity;
+
+namespace PostIt.ViewModels;
+
+public partial class UserProfilePageViewModel : ViewModelBase
+{
+    private readonly YavscApiClient? _api;
+
+    [ObservableProperty]
+    public partial bool IsBusy { get; set; }
+
+    [ObservableProperty]
+    public partial string UserName { get; set; } = "—";
+
+    [ObservableProperty]
+    public partial string FullName { get; set; } = "—";
+
+    [ObservableProperty]
+    public partial string Email { get; set; } = "—";
+
+    [ObservableProperty]
+    public partial string Address { get; set; } = "—";
+
+    [ObservableProperty]
+    public partial string Avatar { get; set; } = "—";
+
+    [ObservableProperty]
+    public partial string Roles { get; set; } = "—";
+
+    [ObservableProperty]
+    public partial string DedicatedGoogleCalendar { get; set; } = "Non configuré";
+
+    [ObservableProperty]
+    public partial string StatusMessage { get; set; } = "Prêt.";
+
+    public override bool CanNavigateNext { get => false; protected set { _ = value; } }
+    public override bool CanNavigatePrevious { get => true; protected set { _ = value; } }
+
+    public UserProfilePageViewModel(YavscApiClient? api)
+    {
+        _api = api;
+    }
+
+    public UserProfilePageViewModel() : this(null) { }
+
+    public Task InitializeAsync() => RefreshAsync();
+
+    [RelayCommand]
+    public async Task RefreshAsync()
+    {
+        if (_api is null)
+        {
+            StatusMessage = "Client API de profil indisponible.";
+            return;
+        }
+
+        IsBusy = true;
+        try
+        {
+            var me = await _api.CallAsync<Me>(HttpMethod.Get, new Uri(new Uri(_api.Settings.ApiUrl.TrimEnd('/') + "/", UriKind.Absolute), "account/me").ToString()).ConfigureAwait(true);
+            UserName = me?.UserName ?? "—";
+            FullName = me?.FullName ?? "—";
+            Email = me?.Email ?? "—";
+            Address = me?.Address ?? "—";
+            Avatar = string.IsNullOrWhiteSpace(me?.Avatar) ? "Aucun avatar" : me.Avatar;
+            Roles = me?.Roles is { Length: > 0 } ? string.Join(", ", me.Roles) : "Aucun rôle";
+            DedicatedGoogleCalendar = string.IsNullOrWhiteSpace(me?.DedicatedGoogleCalendar) ? "Non configuré" : me.DedicatedGoogleCalendar;
+            StatusMessage = "Profil chargé.";
+        }
+        catch (Exception ex)
+        {
+            UserName = "—";
+            FullName = "—";
+            Email = "—";
+            Address = "—";
+            Avatar = "—";
+            Roles = "—";
+            DedicatedGoogleCalendar = "Non configuré";
+            StatusMessage = $"Impossible de charger le profil : {ex.Message}";
+        }
+        finally
+        {
+            IsBusy = false;
+        }
+    }
+
+    [RelayCommand]
+    public async Task SaveProfileAsync()
+    {
+        if (_api is null)
+        {
+            StatusMessage = "Client API de profil indisponible.";
+            return;
+        }
+
+        IsBusy = true;
+        try
+        {
+            var payload = new ProfileUpdateRequest
+            {
+                FullName = FullName,
+                Address = Address
+            };
+
+            var endpoint = new Uri(new Uri(_api.Settings.ApiUrl.TrimEnd('/') + "/", UriKind.Absolute), "account/me").ToString();
+            await _api.CallAsync(HttpMethod.Put, endpoint, payload).ConfigureAwait(true);
+            StatusMessage = "Profil enregistré.";
+            await RefreshAsync().ConfigureAwait(true);
+        }
+        catch (Exception ex)
+        {
+            StatusMessage = $"Impossible d’enregistrer le profil : {ex.Message}";
+        }
+        finally
+        {
+            IsBusy = false;
+        }
+    }
+}
diff --git a/src/PostIt/PostIt/ViewModels/PerformerConfigurationPageViewModel.cs b/src/PostIt/PostIt/ViewModels/PerformerConfigurationPageViewModel.cs
new file mode 100644
index 000000000..bf8318ab5
--- /dev/null
+++ b/src/PostIt/PostIt/ViewModels/PerformerConfigurationPageViewModel.cs
@@ -0,0 +1,175 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Net.Http;
+using System.Threading.Tasks;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using PostIt.Services;
+using Yavsc.Abstract.Workflow;
+using Yavsc.Api.Client;
+
+namespace PostIt.ViewModels;
+
+public partial class ActivitySelectionOption : ObservableObject
+{
+    public string Code { get; }
+    public string Name { get; }
+
+    [ObservableProperty]
+    public partial bool IsSelected { get; set; }
+
+    public ActivitySelectionOption(string code, string name)
+    {
+        Code = code;
+        Name = name;
+    }
+}
+
+public partial class PerformerConfigurationPageViewModel : ViewModelBase
+{
+    private readonly YavscApiClient _api;
+    private readonly ActivityApiClient _activityClient;
+
+    [ObservableProperty]
+    public partial bool IsBusy { get; set; }
+
+    [ObservableProperty]
+    public partial string UserName { get; set; } = "—";
+
+    [ObservableProperty]
+    public partial string ExerciseCountryCode { get; set; } = "fr";
+
+    [ObservableProperty]
+    public partial string SIREN { get; set; } = string.Empty;
+
+    [ObservableProperty]
+    public partial string Website { get; set; } = string.Empty;
+
+    [ObservableProperty]
+    public partial bool Active { get; set; }
+
+    [ObservableProperty]
+    public partial bool AcceptNotifications { get; set; }
+
+    [ObservableProperty]
+    public partial bool AcceptPublicContact { get; set; }
+
+    [ObservableProperty]
+    public partial bool UseGeoLocalizationToReduceDistanceWithClients { get; set; }
+
+    [ObservableProperty]
+    public partial ObservableCollection<ActivitySelectionOption> AvailableActivities { get; set; } = new();
+
+    [ObservableProperty]
+    public partial string StatusMessage { get; set; } = "Prêt.";
+
+    public override bool CanNavigateNext { get => false; protected set { _ = value; } }
+    public override bool CanNavigatePrevious { get => true; protected set { _ = value; } }
+
+    public PerformerConfigurationPageViewModel(YavscApiClient api, ActivityApiClient activityClient)
+    {
+        _api = api ?? throw new ArgumentNullException(nameof(api));
+        _activityClient = activityClient ?? throw new ArgumentNullException(nameof(activityClient));
+    }
+
+    public PerformerConfigurationPageViewModel() : this(null!, null!) { }
+
+    public Task InitializeAsync() => RefreshAsync();
+
+    [RelayCommand]
+    public async Task RefreshAsync()
+    {
+        IsBusy = true;
+        try
+        {
+            var endpoint = new Uri(new Uri(_api.Settings.ApiUrl.TrimEnd('/') + "/", UriKind.Absolute), "account/performer-profile").ToString();
+            var dto = await _api.CallAsync<PerformerProfileSettings>(HttpMethod.Get, endpoint).ConfigureAwait(true);
+
+            UserName = dto?.UserName ?? "—";
+            ExerciseCountryCode = string.IsNullOrWhiteSpace(dto?.ExerciseCountryCode) ? "fr" : dto.ExerciseCountryCode;
+            SIREN = dto?.SIREN ?? string.Empty;
+            Website = dto?.WebSite ?? string.Empty;
+            Active = dto?.Active ?? false;
+            AcceptNotifications = dto?.AcceptNotifications ?? false;
+            AcceptPublicContact = dto?.AcceptPublicContact ?? false;
+            UseGeoLocalizationToReduceDistanceWithClients = dto?.UseGeoLocalizationToReduceDistanceWithClients ?? false;
+
+            var catalog = await _activityClient.GetCatalogAsync().ConfigureAwait(true);
+            var options = Flatten(catalog)
+                .OrderBy(a => a.Name, StringComparer.OrdinalIgnoreCase)
+                .Select(a => new ActivitySelectionOption(a.Code, a.Name)
+                {
+                    IsSelected = dto?.SelectedActivityCodes.Contains(a.Code, StringComparer.OrdinalIgnoreCase) == true
+                })
+                .ToList();
+
+            AvailableActivities.Clear();
+            foreach (var option in options)
+            {
+                AvailableActivities.Add(option);
+            }
+
+            StatusMessage = "Profil performer chargé.";
+        }
+        catch (Exception ex)
+        {
+            StatusMessage = $"Impossible de charger la configuration performer : {ex.Message}";
+        }
+        finally
+        {
+            IsBusy = false;
+        }
+    }
+
+    [RelayCommand]
+    public async Task SaveAsync()
+    {
+        IsBusy = true;
+        try
+        {
+            var dto = new PerformerProfileSettings
+            {
+                PerformerId = string.Empty,
+                UserName = UserName,
+                ExerciseCountryCode = string.IsNullOrWhiteSpace(ExerciseCountryCode) ? "fr" : ExerciseCountryCode,
+                SIREN = SIREN,
+                WebSite = Website,
+                Active = Active,
+                AcceptNotifications = AcceptNotifications,
+                AcceptPublicContact = AcceptPublicContact,
+                UseGeoLocalizationToReduceDistanceWithClients = UseGeoLocalizationToReduceDistanceWithClients,
+                SelectedActivityCodes = AvailableActivities
+                    .Where(a => a.IsSelected)
+                    .Select(a => a.Code)
+                    .Distinct(StringComparer.OrdinalIgnoreCase)
+                    .ToList()
+            };
+
+            var endpoint = new Uri(new Uri(_api.Settings.ApiUrl.TrimEnd('/') + "/", UriKind.Absolute), "account/performer-profile").ToString();
+            var response = await _api.CallAsync<PerformerProfileSettings>(HttpMethod.Put, endpoint, dto).ConfigureAwait(true);
+            StatusMessage = response is not null ? "Configuration performer enregistrée." : "Configuration performer enregistrée.";
+        }
+        catch (Exception ex)
+        {
+            StatusMessage = $"Impossible d’enregistrer la configuration performer : {ex.Message}";
+        }
+        finally
+        {
+            IsBusy = false;
+        }
+    }
+
+    private static IEnumerable<ActivityInfo> Flatten(IEnumerable<ActivityInfo> activities)
+    {
+        foreach (var activity in activities)
+        {
+            yield return activity;
+            foreach (var child in Flatten(activity.Children ?? Enumerable.Empty<ActivityInfo>()))
+            {
+                yield return child;
+            }
+        }
+    }
+}
diff --git a/src/PostIt/PostIt/Views/Layout/AdministrationPage.axaml b/src/PostIt/PostIt/Views/Layout/AdministrationPage.axaml
new file mode 100644
index 000000000..fe2305f16
--- /dev/null
+++ b/src/PostIt/PostIt/Views/Layout/AdministrationPage.axaml
@@ -0,0 +1,42 @@
+<ContentPage xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:vm="using:PostIt.ViewModels"
+             x:Class="PostIt.Views.AdministrationPage"
+             x:DataType="vm:AdministrationPageViewModel"
+             Header="Administration">
+
+  <Grid RowDefinitions="Auto,Auto,Auto,*" Margin="16" RowSpacing="12">
+    <TextBlock Grid.Row="0"
+               Text="Administration"
+               FontSize="22"
+               FontWeight="SemiBold"/>
+
+    <StackPanel Grid.Row="1" Spacing="8">
+      <TextBox Text="{Binding SearchText, Mode=TwoWay}"
+               PlaceholderText="Rechercher un utilisateur..."/>
+      <Button Content="Actualiser"
+              Command="{Binding RefreshCommand}"
+              IsEnabled="{Binding !IsBusy}"/>
+      <ProgressBar IsVisible="{Binding IsBusy}"
+                   IsIndeterminate="True"
+                   Height="8"/>
+      <TextBlock Text="{Binding StatusMessage}"
+                 TextWrapping="Wrap"/>
+    </StackPanel>
+
+    <ListBox Grid.Row="3"
+             ItemsSource="{Binding FilteredUsers}">
+      <ListBox.ItemTemplate>
+        <DataTemplate>
+          <Border Padding="8" BorderBrush="#D0D7DE" BorderThickness="1" CornerRadius="6">
+            <StackPanel Spacing="4">
+              <TextBlock Text="{Binding UserName, StringFormat='Nom : {0}'}" FontWeight="SemiBold"/>
+              <TextBlock Text="{Binding Email, StringFormat='Email : {0}'}" TextWrapping="Wrap"/>
+              <TextBlock Text="{Binding UserId, StringFormat='ID : {0}'}" Foreground="#4B5563" TextWrapping="Wrap"/>
+            </StackPanel>
+          </Border>
+        </DataTemplate>
+      </ListBox.ItemTemplate>
+    </ListBox>
+  </Grid>
+</ContentPage>
diff --git a/src/PostIt/PostIt/Views/Layout/AdministrationPage.axaml.cs b/src/PostIt/PostIt/Views/Layout/AdministrationPage.axaml.cs
new file mode 100644
index 000000000..433bc6111
--- /dev/null
+++ b/src/PostIt/PostIt/Views/Layout/AdministrationPage.axaml.cs
@@ -0,0 +1,11 @@
+using Avalonia.Controls;
+
+namespace PostIt.Views;
+
+public partial class AdministrationPage : ContentPage
+{
+    public AdministrationPage()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/src/PostIt/PostIt/Views/Layout/HomePage.axaml b/src/PostIt/PostIt/Views/Layout/HomePage.axaml
index f2497086d..178bd42d8 100644
--- a/src/PostIt/PostIt/Views/Layout/HomePage.axaml
+++ b/src/PostIt/PostIt/Views/Layout/HomePage.axaml
@@ -44,6 +44,18 @@
               Command="{Binding OpenMyFiles}"
               HorizontalAlignment="Center"
               IsEnabled="{Binding SessionStatus.IsLoggedIn}"/>
+          <Button Content="Mon profil"
+              Command="{Binding OpenProfile}"
+              HorizontalAlignment="Center"
+              IsEnabled="{Binding SessionStatus.IsLoggedIn}"/>
+          <Button Content="Mon activité / performer"
+              Command="{Binding OpenPerformerConfiguration}"
+              HorizontalAlignment="Center"
+              IsEnabled="{Binding SessionStatus.IsLoggedIn}"/>
+          <Button Content="Administration"
+              Command="{Binding OpenAdministration}"
+              HorizontalAlignment="Center"
+              IsEnabled="{Binding SessionStatus.IsLoggedIn}"/>
           <Button Content="Mon usage / administration"
               Command="{Binding OpenResourceUsage}"
               HorizontalAlignment="Center"
diff --git a/src/PostIt/PostIt/Views/Layout/PerformerConfigurationPage.axaml b/src/PostIt/PostIt/Views/Layout/PerformerConfigurationPage.axaml
new file mode 100644
index 000000000..56ec89f2c
--- /dev/null
+++ b/src/PostIt/PostIt/Views/Layout/PerformerConfigurationPage.axaml
@@ -0,0 +1,59 @@
+<ContentPage xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:vm="using:PostIt.ViewModels"
+             x:Class="PostIt.Views.PerformerConfigurationPage"
+             x:DataType="vm:PerformerConfigurationPageViewModel"
+             Header="Mon activité / performer">
+
+  <ScrollViewer>
+    <StackPanel Margin="16" Spacing="12">
+      <TextBlock Text="Mon activité / performer"
+                 FontSize="22"
+                 FontWeight="SemiBold"/>
+
+      <Button Content="Actualiser"
+              Command="{Binding RefreshCommand}"
+              IsEnabled="{Binding !IsBusy}"/>
+
+      <ProgressBar IsVisible="{Binding IsBusy}"
+                   IsIndeterminate="True"
+                   Height="8"/>
+
+      <TextBlock Text="{Binding UserName, StringFormat='Nom d’utilisateur : {0}'}"/>
+      <TextBox Text="{Binding ExerciseCountryCode, Mode=TwoWay}"
+               Watermark="Code pays (fr, en...)"/>
+      <TextBox Text="{Binding SIREN, Mode=TwoWay}"
+               Watermark="SIREN"/>
+      <TextBox Text="{Binding Website, Mode=TwoWay}"
+               Watermark="Site web"/>
+
+      <CheckBox Content="Disponible / actif"
+                IsChecked="{Binding Active, Mode=TwoWay}"/>
+      <CheckBox Content="Accepter les notifications"
+                IsChecked="{Binding AcceptNotifications, Mode=TwoWay}"/>
+      <CheckBox Content="Accepter les demandes publiques"
+                IsChecked="{Binding AcceptPublicContact, Mode=TwoWay}"/>
+      <CheckBox Content="Utiliser la géolocalisation"
+                IsChecked="{Binding UseGeoLocalizationToReduceDistanceWithClients, Mode=TwoWay}"/>
+
+      <TextBlock Text="Activités" FontWeight="SemiBold"/>
+      <ItemsControl ItemsSource="{Binding AvailableActivities}">
+        <ItemsControl.ItemTemplate>
+          <DataTemplate>
+            <CheckBox Margin="0,0,0,6"
+                      Content="{Binding Name}"
+                      IsChecked="{Binding IsSelected, Mode=TwoWay}"/>
+          </DataTemplate>
+        </ItemsControl.ItemTemplate>
+      </ItemsControl>
+
+      <Button Content="Enregistrer"
+              Command="{Binding SaveCommand}"
+              IsEnabled="{Binding !IsBusy}"/>
+
+      <TextBlock Text="{Binding StatusMessage}"
+                 Foreground="#4B5563"
+                 TextWrapping="Wrap"/>
+    </StackPanel>
+  </ScrollViewer>
+</ContentPage>
diff --git a/src/PostIt/PostIt/Views/Layout/PerformerConfigurationPage.axaml.cs b/src/PostIt/PostIt/Views/Layout/PerformerConfigurationPage.axaml.cs
new file mode 100644
index 000000000..928bbe922
--- /dev/null
+++ b/src/PostIt/PostIt/Views/Layout/PerformerConfigurationPage.axaml.cs
@@ -0,0 +1,11 @@
+using Avalonia.Controls;
+
+namespace PostIt.Views;
+
+public partial class PerformerConfigurationPage : ContentPage
+{
+    public PerformerConfigurationPage()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/src/PostIt/PostIt/Views/Layout/UserProfilePage.axaml b/src/PostIt/PostIt/Views/Layout/UserProfilePage.axaml
new file mode 100644
index 000000000..f07351682
--- /dev/null
+++ b/src/PostIt/PostIt/Views/Layout/UserProfilePage.axaml
@@ -0,0 +1,34 @@
+<ContentPage xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:vm="using:PostIt.ViewModels"
+             x:Class="PostIt.Views.UserProfilePage"
+             x:DataType="vm:UserProfilePageViewModel"
+             Header="Mon profil">
+
+  <StackPanel Margin="16" Spacing="12">
+    <TextBlock Text="Mon profil"
+               FontSize="22"
+               FontWeight="SemiBold"/>
+
+    <Button Content="Actualiser"
+            Command="{Binding RefreshCommand}"
+            IsEnabled="{Binding !IsBusy}"/>
+
+    <ProgressBar IsVisible="{Binding IsBusy}"
+                 IsIndeterminate="True"
+                 Height="8"/>
+
+    <Grid RowDefinitions="Auto,Auto,Auto,Auto" ColumnDefinitions="*" RowSpacing="8">
+      <TextBox Watermark="Nom complet" Text="{Binding FullName}"/>
+      <TextBox Grid.Row="1" Watermark="Adresse" Text="{Binding Address}" AcceptsReturn="True" TextWrapping="Wrap"/>
+      <Button Grid.Row="2" Content="Enregistrer" Command="{Binding SaveProfileCommand}" IsEnabled="{Binding !IsBusy}"/>
+    </Grid>
+
+    <TextBlock Text="{Binding UserName, StringFormat='Nom d’utilisateur : {0}'}"/>
+    <TextBlock Text="{Binding Email, StringFormat='Email : {0}'}"/>
+    <TextBlock Text="{Binding Roles, StringFormat='Rôles : {0}'}"/>
+    <TextBlock Text="{Binding DedicatedGoogleCalendar, StringFormat='Calendrier dédié : {0}'}"/>
+    <TextBlock Text="{Binding Avatar, StringFormat='Avatar : {0}'}" TextWrapping="Wrap"/>
+    <TextBlock Text="{Binding StatusMessage}" Foreground="#4B5563" TextWrapping="Wrap"/>
+  </StackPanel>
+</ContentPage>
diff --git a/src/PostIt/PostIt/Views/Layout/UserProfilePage.axaml.cs b/src/PostIt/PostIt/Views/Layout/UserProfilePage.axaml.cs
new file mode 100644
index 000000000..c3be9ad8d
--- /dev/null
+++ b/src/PostIt/PostIt/Views/Layout/UserProfilePage.axaml.cs
@@ -0,0 +1,11 @@
+using Avalonia.Controls;
+
+namespace PostIt.Views;
+
+public partial class UserProfilePage : ContentPage
+{
+    public UserProfilePage()
+    {
+        InitializeComponent();
+    }
+}
diff --git a/src/Yavsc.Abstract/Constants.cs b/src/Yavsc.Abstract/Constants.cs
index ca871f9d5..0d06582bf 100644
--- a/src/Yavsc.Abstract/Constants.cs
+++ b/src/Yavsc.Abstract/Constants.cs
@@ -30,6 +30,13 @@ namespace Yavsc
         public const string UserNameRegExp = @"^[a-zA-Z][a-zA-Z0-9._-]*$";
         public const string UserFileNamePatternRegExp = @"^([a-zA-Z0-9._-]*/)*[a-zA-Z0-9._-]+$";
 
+        public const string ResourceUsagePath = "resource-usage";
+        public const string ResourceUsageCurrentUserRoute = "me";
+        public const string ResourceUsageAdminRoute = "admin";
+        public const string ResourceUsageDefaultCurrency = "EUR";
+        public const string ResourceUsageCurrentUserDisplayName = "current-user";
+        public const string ResourceUsageAdminDisplayName = "administrator";
+
         public const string SigninPath = "~/signin";
         public const string LogoutPath = "~/signout";
 
diff --git a/src/Yavsc.Abstract/Identity/Me.cs b/src/Yavsc.Abstract/Identity/Me.cs
index 1996cb9ad..ab620df41 100644
--- a/src/Yavsc.Abstract/Identity/Me.cs
+++ b/src/Yavsc.Abstract/Identity/Me.cs
@@ -1,9 +1,11 @@
+#nullable enable
+
 namespace Yavsc.Abstract.Identity {
   public class Me : UserInfo
   {
-      public AuthToken Token {
+      public AuthToken? Token {
           get;
           set;
       }
   }
-} 
+}
diff --git a/src/Yavsc.Abstract/Identity/ProfileUpdateRequest.cs b/src/Yavsc.Abstract/Identity/ProfileUpdateRequest.cs
new file mode 100644
index 000000000..f7534fbb3
--- /dev/null
+++ b/src/Yavsc.Abstract/Identity/ProfileUpdateRequest.cs
@@ -0,0 +1,9 @@
+#nullable enable
+
+namespace Yavsc.Abstract.Identity;
+
+public class ProfileUpdateRequest
+{
+    public string? FullName { get; set; }
+    public string? Address { get; set; }
+}
diff --git a/src/Yavsc.Abstract/Identity/UserInfo.cs b/src/Yavsc.Abstract/Identity/UserInfo.cs
index 5ddf5e91e..40c60be93 100644
--- a/src/Yavsc.Abstract/Identity/UserInfo.cs
+++ b/src/Yavsc.Abstract/Identity/UserInfo.cs
@@ -1,10 +1,11 @@
+#nullable enable
+
 namespace  Yavsc.Abstract.Identity
 {
     public class UserInfo {
 
         public UserInfo()
         {
-
         }
 
         public UserInfo(string userId, string userName, string email, string avatar)
@@ -14,10 +15,14 @@ namespace  Yavsc.Abstract.Identity
             Email = email;
             Avatar = avatar;
         }
-        public string UserId { get; set; }
 
-        public string UserName { get; set; }
-        public string Email { get; }
-        public string Avatar { get; set; }
+        public string UserId { get; set; } = string.Empty;
+        public string? UserName { get; set; }
+        public string? FullName { get; set; }
+        public string? Email { get; set; }
+        public string? Address { get; set; }
+        public string? Avatar { get; set; }
+        public string[] Roles { get; set; } = [];
+        public string? DedicatedGoogleCalendar { get; set; }
     }
 }
diff --git a/src/Yavsc.Abstract/Resources/ResourceUsageSummary.cs b/src/Yavsc.Abstract/Resources/ResourceUsageSummary.cs
new file mode 100644
index 000000000..c53d1b1a5
--- /dev/null
+++ b/src/Yavsc.Abstract/Resources/ResourceUsageSummary.cs
@@ -0,0 +1,22 @@
+namespace Yavsc.Abstract.Resources;
+
+/// <summary>
+/// Lightweight usage snapshot for PostIt / Yavsc resource accounting.
+/// The initial implementation is intentionally intentionally small and
+/// serialisable so it can be exposed through the API and consumed by the
+/// PostIt client without requiring a full database model yet.
+/// </summary>
+public sealed class ResourceUsageSummary
+{
+    public string UserId { get; set; } = string.Empty;
+    public string UserName { get; set; } = string.Empty;
+    public DateTimeOffset RecordedAtUtc { get; set; }
+
+    public decimal ApiCalls { get; set; }
+    public decimal CpuSeconds { get; set; }
+    public decimal BandwidthMb { get; set; }
+    public decimal StorageMb { get; set; }
+
+    public decimal EstimatedCompensation { get; set; }
+    public string Currency { get; set; } = Constants.ResourceUsageDefaultCurrency;
+}
diff --git a/src/Yavsc.Abstract/Workflow/PerformerProfileSettings.cs b/src/Yavsc.Abstract/Workflow/PerformerProfileSettings.cs
new file mode 100644
index 000000000..29149269e
--- /dev/null
+++ b/src/Yavsc.Abstract/Workflow/PerformerProfileSettings.cs
@@ -0,0 +1,15 @@
+namespace Yavsc.Abstract.Workflow;
+
+public sealed class PerformerProfileSettings
+{
+    public string PerformerId { get; set; } = string.Empty;
+    public string UserName { get; set; } = string.Empty;
+    public string ExerciseCountryCode { get; set; } = "fr";
+    public string SIREN { get; set; } = string.Empty;
+    public string WebSite { get; set; } = string.Empty;
+    public bool Active { get; set; }
+    public bool AcceptNotifications { get; set; }
+    public bool AcceptPublicContact { get; set; }
+    public bool UseGeoLocalizationToReduceDistanceWithClients { get; set; }
+    public List<string> SelectedActivityCodes { get; set; } = new();
+}
diff --git a/src/Yavsc.Api.Client/ResourceUsageApiClient.cs b/src/Yavsc.Api.Client/ResourceUsageApiClient.cs
new file mode 100644
index 000000000..f4a040d68
--- /dev/null
+++ b/src/Yavsc.Api.Client/ResourceUsageApiClient.cs
@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using Yavsc.Abstract.Resources;
+
+namespace Yavsc.Api.Client;
+
+/// <summary>
+/// Thin HTTP client for the PostIt resource-usage reporting flow.
+/// It follows the same pattern as the other Yavsc API clients: absolute
+/// paths, JSON request/response mapping, and no application logic.
+/// </summary>
+public sealed class ResourceUsageApiClient
+{
+    private const string PathPrefix = Constants.ResourceUsagePath;
+
+    private readonly IYavscApiClient _api;
+    private readonly Func<string> _businessBaseAddress;
+
+    public ResourceUsageApiClient(IYavscApiClient api, string businessBaseAddress)
+        : this(api, () => businessBaseAddress)
+    {
+    }
+
+    public ResourceUsageApiClient(IYavscApiClient api, Func<string> businessBaseAddress)
+    {
+        _api = api ?? throw new ArgumentNullException(nameof(api));
+        _businessBaseAddress = businessBaseAddress ?? throw new ArgumentNullException(nameof(businessBaseAddress));
+        _ = ResolveBusinessBaseAddress();
+    }
+
+    public Task<ResourceUsageSummary> GetCurrentAsync(CancellationToken ct = default)
+    {
+        return _api.CallAsync<ResourceUsageSummary>(
+            HttpMethod.Get,
+            Absolute($"{PathPrefix}/{Constants.ResourceUsageCurrentUserRoute}"),
+            ct: ct);
+    }
+
+    public Task<List<ResourceUsageSummary>> GetAdminOverviewAsync(CancellationToken ct = default)
+    {
+        return _api.CallAsync<List<ResourceUsageSummary>>(
+            HttpMethod.Get,
+            Absolute($"{PathPrefix}/{Constants.ResourceUsageAdminRoute}"),
+            ct: ct);
+    }
+
+    private string Absolute(string relativePath) => new Uri(ResolveBusinessBaseAddress(), relativePath).ToString();
+
+    private Uri ResolveBusinessBaseAddress()
+    {
+        var raw = _businessBaseAddress();
+        if (string.IsNullOrWhiteSpace(raw))
+            throw new InvalidOperationException("Business base address is required.");
+
+        return new Uri(raw, UriKind.Absolute);
+    }
+}
diff --git a/src/Yavsc.Api/Controllers/Administration/ResourceUsageApiController.cs b/src/Yavsc.Api/Controllers/Administration/ResourceUsageApiController.cs
new file mode 100644
index 000000000..0f6af3083
--- /dev/null
+++ b/src/Yavsc.Api/Controllers/Administration/ResourceUsageApiController.cs
@@ -0,0 +1,96 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using Yavsc.Abstract.Resources;
+using Yavsc.Models;
+using Yavsc.Server.Helpers;
+
+namespace Yavsc.ApiControllers.Administration;
+
+[Produces("application/json")]
+[Authorize]
+[Route(Constants.APIPrefix + "/" + Constants.ResourceUsagePath)]
+public sealed class ResourceUsageApiController : Controller
+{
+    private readonly ApplicationDbContext _dbContext;
+
+    public ResourceUsageApiController(ApplicationDbContext dbContext)
+    {
+        _dbContext = dbContext;
+    }
+
+    private static ResourceUsageSummary ToSummary(ResourceUsageRecord record)
+        => new()
+        {
+            UserId = record.UserId,
+            UserName = record.UserName,
+            RecordedAtUtc = new DateTimeOffset(record.RecordedAtUtc, TimeSpan.Zero),
+            ApiCalls = record.ApiCalls,
+            CpuSeconds = record.CpuSeconds,
+            BandwidthMb = record.BandwidthMb,
+            StorageMb = record.StorageMb,
+            EstimatedCompensation = record.EstimatedCompensation,
+            Currency = record.Currency
+        };
+
+    [HttpGet(Constants.ResourceUsageCurrentUserRoute)]
+    public async Task<ActionResult<ResourceUsageSummary>> GetCurrentUserUsage()
+    {
+        var userId = User.GetUserId();
+        if (string.IsNullOrWhiteSpace(userId))
+        {
+            return Unauthorized();
+        }
+
+        var userName = User.Identity?.Name ?? Constants.ResourceUsageCurrentUserDisplayName;
+        var record = await _dbContext.ResourceUsageRecords
+            .Where(r => r.UserId == userId)
+            .OrderByDescending(r => r.RecordedAtUtc)
+            .FirstOrDefaultAsync();
+
+        if (record is null)
+        {
+            var zeroUsage = new ResourceUsageRecord
+            {
+                UserId = userId,
+                UserName = userName,
+                RecordedAtUtc = DateTime.UtcNow,
+                ApiCalls = 0m,
+                CpuSeconds = 0m,
+                BandwidthMb = 0m,
+                StorageMb = 0m,
+                EstimatedCompensation = 0m,
+                Currency = Constants.ResourceUsageDefaultCurrency,
+                UserCreated = userId,
+                UserModified = userId,
+                DateCreated = DateTime.UtcNow,
+                DateModified = DateTime.UtcNow,
+            };
+
+            _dbContext.ResourceUsageRecords.Add(zeroUsage);
+            await _dbContext.SaveChangesAsync(userId);
+            return Ok(ToSummary(zeroUsage));
+        }
+
+        return Ok(ToSummary(record));
+    }
+
+    [HttpGet(Constants.ResourceUsageAdminRoute)]
+    public async Task<ActionResult<List<ResourceUsageSummary>>> GetAdminOverview()
+    {
+        if (!User.IsInRole(Constants.AdminGroupName))
+        {
+            return Forbid();
+        }
+
+        var latestByUser = (await _dbContext.ResourceUsageRecords
+                .OrderByDescending(r => r.RecordedAtUtc)
+                .ToListAsync())
+            .GroupBy(r => r.UserId)
+            .Select(g => g.First())
+            .OrderByDescending(r => r.RecordedAtUtc)
+            .ToList();
+
+        return Ok(latestByUser.Select(ToSummary).ToList());
+    }
+}
diff --git a/src/Yavsc.Api/Controllers/Business/FrontOfficeApiController.cs b/src/Yavsc.Api/Controllers/Business/FrontOfficeApiController.cs
index e5b89c4a9..9da7d0a94 100644
--- a/src/Yavsc.Api/Controllers/Business/FrontOfficeApiController.cs
+++ b/src/Yavsc.Api/Controllers/Business/FrontOfficeApiController.cs
@@ -1,3 +1,4 @@
+using System.Diagnostics;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.AspNetCore.Mvc.Razor;
@@ -129,6 +130,9 @@ namespace Yavsc.ApiControllers
                 Temp = siteSettings.TempDir,
             };
 
+            var stopwatch = Stopwatch.StartNew();
+            FileInfo? renderedPdf = null;
+
             try
             {
                 // 1. Render the LaTeX template (Estimate_tex) to a TeX source
@@ -141,10 +145,28 @@ namespace Yavsc.ApiControllers
                 //    we stream the generated PDF bytes — but driving the
                 //    generation through the view keeps the template as the
                 //    output producer, per the original design.
-                if (model.GenerateEstimatePdf() is FileInfo fo && fo.Exists)
+                renderedPdf = model.GenerateEstimatePdf();
+                if (renderedPdf is FileInfo fo && fo.Exists)
                 {
-                     return File(fo.OpenRead(), "application/pdf");
+                    await ResourceUsageTracker.RecordAsync(
+                        dbContext,
+                        uid,
+                        User.Identity?.Name ?? uid,
+                        cpuSeconds: (decimal)stopwatch.Elapsed.TotalSeconds,
+                        storageBytes: fo.Length,
+                        actorUserId: uid);
+
+                    return File(fo.OpenRead(), "application/pdf");
                 }
+
+                await ResourceUsageTracker.RecordAsync(
+                    dbContext,
+                    uid,
+                    User.Identity?.Name ?? uid,
+                    cpuSeconds: (decimal)stopwatch.Elapsed.TotalSeconds,
+                    storageBytes: 0,
+                    actorUserId: uid);
+
                 string msg = "TeX render failed: " + model.GenerationErrorMessage;
                 logger.LogError(msg);
                 return Problem(msg);
@@ -152,6 +174,14 @@ namespace Yavsc.ApiControllers
             }
             catch (Exception ex)
             {
+                await ResourceUsageTracker.RecordAsync(
+                    dbContext,
+                    uid,
+                    User.Identity?.Name ?? uid,
+                    cpuSeconds: (decimal)stopwatch.Elapsed.TotalSeconds,
+                    storageBytes: renderedPdf?.Length ?? 0,
+                    actorUserId: uid);
+
                 logger.LogError(ex, "estimate {QueryId}: TeX/PDF render failed", queryId);
                 return Problem("TeX render failed: " + ex.Message);
             }
diff --git a/src/Yavsc.Api/Controllers/accounting/AccountController.cs b/src/Yavsc.Api/Controllers/accounting/AccountController.cs
index f0986e98f..9a35e3936 100644
--- a/src/Yavsc.Api/Controllers/accounting/AccountController.cs
+++ b/src/Yavsc.Api/Controllers/accounting/AccountController.cs
@@ -9,6 +9,8 @@ using Yavsc.Api.Helpers;
 using Yavsc.Server.Helpers;
 using System.Diagnostics;
 using Microsoft.Extensions.Options;
+using Yavsc.Abstract.Identity;
+using Yavsc.Abstract.Workflow;
 
 namespace Yavsc.WebApi.Controllers
 {
@@ -30,14 +32,16 @@ namespace Yavsc.WebApi.Controllers
         readonly ApplicationDbContext _dbContext;
         private readonly SiteSettings siteSettings;
         private readonly ILogger _logger;
+        private readonly UserManager<ApplicationUser> _userManager;
 
         public ApiAccountController(
         ILoggerFactory loggerFactory, ApplicationDbContext dbContext,
-        IOptions<SiteSettings> siteSettings)
+        IOptions<SiteSettings> siteSettings, UserManager<ApplicationUser> userManager)
         {
             _logger = loggerFactory.CreateLogger(nameof(ApiAccountController));
             _dbContext = dbContext;
             this.siteSettings = siteSettings.Value;
+            _userManager = userManager;
         }
 
         [HttpGet("me")]
@@ -52,7 +56,8 @@ namespace Yavsc.WebApi.Controllers
             Debug.Assert(userData != null, "userData is null");
             var user = new Yavsc.Models.Auth.Me(userData.Id, userData.UserName, userData.Email,
             userData.Avatar,
-            userData.PostalAddress, userData.DedicatedGoogleCalendar);
+            userData.PostalAddress, userData.DedicatedGoogleCalendar, userData.FullName);
+            user.Address = userData.PostalAddress?.Address ?? string.Empty;
 
             var userRoles = _dbContext.UserRoles.Where(u => u.UserId == uid).Select(r => r.RoleId).ToArray();
 
@@ -71,6 +76,190 @@ namespace Yavsc.WebApi.Controllers
                             .FirstAsync(u => u.Id == uid);
         }
 
+        [HttpPut("me")]
+        public async Task<IActionResult> UpdateMe([FromBody] ProfileUpdateRequest request)
+        {
+            if (request is null)
+            {
+                return BadRequest(new { error = "Payload is required." });
+            }
+
+            var uid = User.GetUserId();
+            if (string.IsNullOrWhiteSpace(uid))
+            {
+                return Challenge();
+            }
+
+            var user = await _dbContext.Users
+                .Include(u => u.PostalAddress)
+                .FirstOrDefaultAsync(u => u.Id == uid);
+
+            if (user is null)
+            {
+                return NotFound();
+            }
+
+            if (!string.IsNullOrWhiteSpace(request.FullName))
+            {
+                user.FullName = request.FullName.Trim();
+            }
+
+            if (!string.IsNullOrWhiteSpace(request.Address))
+            {
+                if (user.PostalAddress is null)
+                {
+                    user.PostalAddress = new Yavsc.Models.Relationship.Location { Address = request.Address.Trim() };
+                }
+                else
+                {
+                    user.PostalAddress.Address = request.Address.Trim();
+                }
+            }
+
+            await _dbContext.SaveChangesAsync(uid);
+            return Ok(new { status = "saved", fullName = user.FullName, address = user.PostalAddress?.Address });
+        }
+
+        [HttpGet("performer-profile")]
+        public async Task<IActionResult> GetPerformerProfile()
+        {
+            var uid = User.GetUserId();
+            if (string.IsNullOrWhiteSpace(uid))
+            {
+                return Challenge();
+            }
+
+            var profile = await _dbContext.Performers
+                .AsNoTracking()
+                .FirstOrDefaultAsync(p => p.PerformerId == uid);
+
+            var selectedActivityCodes = await _dbContext.UserActivities
+                .AsNoTracking()
+                .Where(x => x.UserId == uid)
+                .Select(x => x.DoesCode)
+                .ToListAsync();
+
+            return Ok(new PerformerProfileSettings
+            {
+                PerformerId = uid,
+                UserName = User.Identity?.Name ?? string.Empty,
+                ExerciseCountryCode = profile?.ExerciseCountryCode ?? "fr",
+                SIREN = profile?.SIREN ?? string.Empty,
+                WebSite = profile?.WebSite ?? string.Empty,
+                Active = profile?.Active ?? false,
+                AcceptNotifications = profile?.AcceptNotifications ?? false,
+                AcceptPublicContact = profile?.AcceptPublicContact ?? false,
+                UseGeoLocalizationToReduceDistanceWithClients = profile?.UseGeoLocalizationToReduceDistanceWithClients ?? false,
+                SelectedActivityCodes = selectedActivityCodes
+            });
+        }
+
+        [HttpPut("performer-profile")]
+        public async Task<IActionResult> SavePerformerProfile([FromBody] PerformerProfileSettings model)
+        {
+            if (model is null)
+            {
+                return BadRequest(new { error = "Payload is required." });
+            }
+
+            var uid = User.GetUserId();
+            if (string.IsNullOrWhiteSpace(uid) || !string.Equals(model.PerformerId, uid, StringComparison.Ordinal))
+            {
+                return Forbid();
+            }
+
+            var user = await _dbContext.Users.FirstOrDefaultAsync(u => u.Id == uid);
+            if (user is null)
+            {
+                return NotFound();
+            }
+
+            if (string.IsNullOrWhiteSpace(model.ExerciseCountryCode))
+            {
+                model.ExerciseCountryCode = "fr";
+            }
+
+            var profile = await _dbContext.Performers.FirstOrDefaultAsync(p => p.PerformerId == uid);
+            if (profile is null)
+            {
+                profile = new Yavsc.Models.Workflow.PerformerProfile
+                {
+                    PerformerId = uid,
+                    Performer = user,
+                    ExerciseCountryCode = model.ExerciseCountryCode,
+                    SIREN = model.SIREN ?? string.Empty,
+                    WebSite = model.WebSite ?? string.Empty,
+                    Active = model.Active,
+                    AcceptNotifications = model.AcceptNotifications,
+                    AcceptPublicContact = model.AcceptPublicContact,
+                    UseGeoLocalizationToReduceDistanceWithClients = model.UseGeoLocalizationToReduceDistanceWithClients,
+                    OrganizationAddress = new Yavsc.Models.Relationship.Location()
+                };
+                _dbContext.Performers.Add(profile);
+            }
+            else
+            {
+                profile.ExerciseCountryCode = model.ExerciseCountryCode;
+                profile.SIREN = model.SIREN ?? string.Empty;
+                profile.WebSite = model.WebSite ?? string.Empty;
+                profile.Active = model.Active;
+                profile.AcceptNotifications = model.AcceptNotifications;
+                profile.AcceptPublicContact = model.AcceptPublicContact;
+                profile.UseGeoLocalizationToReduceDistanceWithClients = model.UseGeoLocalizationToReduceDistanceWithClients;
+            }
+
+            var desiredCodes = (model.SelectedActivityCodes ?? [])
+                .Where(code => !string.IsNullOrWhiteSpace(code))
+                .Distinct(StringComparer.OrdinalIgnoreCase)
+                .ToList();
+
+            var existingLinks = await _dbContext.UserActivities
+                .Where(x => x.UserId == uid)
+                .ToListAsync();
+
+            foreach (var link in existingLinks)
+            {
+                if (!desiredCodes.Contains(link.DoesCode, StringComparer.OrdinalIgnoreCase))
+                {
+                    _dbContext.UserActivities.Remove(link);
+                }
+            }
+
+            foreach (var code in desiredCodes)
+            {
+                if (existingLinks.Any(x => string.Equals(x.DoesCode, code, StringComparison.OrdinalIgnoreCase)))
+                {
+                    continue;
+                }
+
+                var activity = await _dbContext.Activities
+                    .FirstOrDefaultAsync(a => a.Code == code);
+
+                if (activity is not null)
+                {
+                    _dbContext.UserActivities.Add(new Yavsc.Models.Workflow.UserActivity
+                    {
+                        UserId = uid,
+                        DoesCode = activity.Code,
+                        Weight = 100
+                    });
+                }
+            }
+
+            await _dbContext.SaveChangesAsync(uid);
+
+            if (!User.IsInRole("Performer"))
+            {
+                var roleResult = await _userManager.AddToRoleAsync(user, "Performer");
+                if (!roleResult.Succeeded)
+                {
+                    return BadRequest(new { error = "Performer role could not be assigned.", details = roleResult.Errors.Select(e => e.Description) });
+                }
+            }
+
+            return Ok(new { status = "saved", performer = model });
+        }
+
         [HttpGet("myhost")]
         public IActionResult MyHost ()
         {
diff --git a/src/Yavsc.Api/Program.cs b/src/Yavsc.Api/Program.cs
index 23c0c77fd..d58789201 100644
--- a/src/Yavsc.Api/Program.cs
+++ b/src/Yavsc.Api/Program.cs
@@ -54,6 +54,13 @@ internal class Program
                         .RequireAuthenticatedUser()
                         .RequireClaim(JwtClaimTypes.Scope, new string[] { "api" });
                 });
+
+                options.AddPolicy("AdministratorOnly", policy =>
+                {
+                    policy
+                        .RequireAuthenticatedUser()
+                        .RequireClaim(Constants.RoleClaimType, Constants.AdminGroupName);
+                });
             })
             .AddYavscCors(builder.Configuration)
             .AddControllersWithViews();
@@ -116,6 +123,7 @@ internal class Program
             if (app.Environment.IsDevelopment())
                 app.UseDeveloperExceptionPage();
 
+            app.UseMiddleware<ResourceUsageTelemetryMiddleware>();
             app
                 .UseRouting()
                 .UseAuthentication()
diff --git a/src/Yavsc.Blogs/Controllers/FileSystemApiController.cs b/src/Yavsc.Blogs/Controllers/FileSystemApiController.cs
index 2ca4250c0..e67b366a5 100644
--- a/src/Yavsc.Blogs/Controllers/FileSystemApiController.cs
+++ b/src/Yavsc.Blogs/Controllers/FileSystemApiController.cs
@@ -99,7 +99,7 @@ namespace Yavsc.Blogs.Controllers
         }
 
         [HttpPost("{*subdir}")]
-        public IActionResult Post([ValidRemoteUserFilePath] string subdir="")
+        public async Task<IActionResult> Post([ValidRemoteUserFilePath] string subdir="")
         {
             if (!ModelState.IsValid) return new BadRequestObjectResult(ModelState);
             string destDir = null;
@@ -159,6 +159,14 @@ namespace Yavsc.Blogs.Controllers
                     item.Length = f.Length;
                     item.ContentType = f.ContentType;
                 }
+
+                await ResourceUsageTracker.RecordAsync(
+                    dbContext,
+                    uid,
+                    user.UserName,
+                    storageBytes: item.Length,
+                    actorUserId: uid);
+
                 received.Add(item);
                 _logger.LogInformation($"Received  '{item.FileName}'.");
                 if (item.QuotaOffense)
diff --git a/src/Yavsc.Blogs/Program.cs b/src/Yavsc.Blogs/Program.cs
index d3d094294..21a26e637 100644
--- a/src/Yavsc.Blogs/Program.cs
+++ b/src/Yavsc.Blogs/Program.cs
@@ -83,7 +83,7 @@ internal class Program
             .AddSupportedCultures(supportedCultures)
             .AddSupportedUICultures(supportedCultures);
         })
-        .Configure<SiteSettings>(settings => 
+        .Configure<SiteSettings>(settings =>
         {
             if (settings.Blog == null)
             {
@@ -98,6 +98,7 @@ internal class Program
         {
             if (app.Environment.IsDevelopment())
                 app.UseDeveloperExceptionPage();
+            app.UseMiddleware<ResourceUsageTelemetryMiddleware>();
             app
                 .UseRouting()
                 .UseAuthentication()
diff --git a/src/Yavsc.Org/Migrations/20261007011348_ResourceUsageRecords.Designer.cs b/src/Yavsc.Org/Migrations/20261007011348_ResourceUsageRecords.Designer.cs
new file mode 100644
index 000000000..257d18e02
--- /dev/null
+++ b/src/Yavsc.Org/Migrations/20261007011348_ResourceUsageRecords.Designer.cs
@@ -0,0 +1,4859 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+using Yavsc.Models;
+
+#nullable disable
+
+namespace Yavsc.Migrations
+{
+    [DbContext(typeof(ApplicationDbContext))]
+    [Migration("20261007011348_ResourceUsageRecords")]
+    partial class ResourceUsageRecords
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "10.0.12")
+                .HasAnnotation("Relational:MaxIdentifierLength", 63);
+
+            NpgsqlModelBuilderExtensions.UseIdentityByDefaultColumns(modelBuilder);
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResource", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityAlwaysColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("AllowedAccessTokenSigningAlgorithms")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastAccessed")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("NonEditable")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("ShowInDiscoveryDocument")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("Updated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ApiResources");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceClaim", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ApiResourceId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ApiResourceId1")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApiResourceId");
+
+                    b.HasIndex("ApiResourceId1");
+
+                    b.ToTable("ApiResourceClaims");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceProperty", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ApiResourceId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ApiResourceId1")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApiResourceId");
+
+                    b.HasIndex("ApiResourceId1");
+
+                    b.ToTable("ApiResourceProperties");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceScope", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ApiResourceId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ApiResourceId1")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Scope")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApiResourceId");
+
+                    b.HasIndex("ApiResourceId1");
+
+                    b.ToTable("ApiResourceScopes");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceSecret", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ApiResourceId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ApiResourceId1")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("Expiration")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApiResourceId");
+
+                    b.HasIndex("ApiResourceId1");
+
+                    b.ToTable("ApiResourceSecrets");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScope", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityAlwaysColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Emphasize")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Required")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("ShowInDiscoveryDocument")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("ApiScopes");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeClaim", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ScopeId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ScopeId1")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ScopeId");
+
+                    b.HasIndex("ScopeId1");
+
+                    b.ToTable("ApiScopeClaims");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeProperty", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Key")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ScopeId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ScopeId1")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ScopeId");
+
+                    b.HasIndex("ScopeId1");
+
+                    b.ToTable("ApiScopeProperties");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.Client", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityAlwaysColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("AbsoluteRefreshTokenLifetime")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AccessTokenLifetime")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("AccessTokenType")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("AllowAccessTokensViaBrowser")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("AllowOfflineAccess")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("AllowPlainTextPkce")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("AllowRememberConsent")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("AllowedIdentityTokenSigningAlgorithms")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("AlwaysIncludeUserClaimsInIdToken")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("AlwaysSendClientClaims")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("AuthorizationCodeLifetime")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("BackChannelLogoutSessionRequired")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("BackChannelLogoutUri")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClientClaimsPrefix")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClientId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClientName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClientUri")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("ConsentLifetime")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<int>("DeviceCodeLifetime")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("EnableLocalLogin")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("FrontChannelLogoutSessionRequired")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("FrontChannelLogoutUri")
+                        .HasColumnType("text");
+
+                    b.Property<int>("IdentityTokenLifetime")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("IncludeJwtId")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("LastAccessed")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("LogoUri")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("NonEditable")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("PairWiseSubjectSalt")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProtocolType")
+                        .HasColumnType("text");
+
+                    b.Property<int>("RefreshTokenExpiration")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("RefreshTokenUsage")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("RequireClientSecret")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("RequireConsent")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("RequirePkce")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("RequireRequestObject")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("SlidingRefreshTokenLifetime")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("UpdateAccessTokenClaimsOnRefresh")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("Updated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("UserCodeType")
+                        .HasColumnType("text");
+
+                    b.Property<int?>("UserSsoLifetime")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Clients");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientClaim", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityAlwaysColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ClientId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientId");
+
+                    b.ToTable("ClientClaims");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientCorsOrigin", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityAlwaysColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ClientId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ClientId1")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Origin")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientId");
+
+                    b.HasIndex("ClientId1");
+
+                    b.ToTable("ClientCorsOrigins");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientGrantType", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityAlwaysColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ClientId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("GrantType")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientId");
+
+                    b.ToTable("ClientGrantTypes");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientIdPRestriction", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityAlwaysColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ClientId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ClientId1")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Provider")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientId");
+
+                    b.HasIndex("ClientId1");
+
+                    b.ToTable("ClientIdPRestrictions");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientPostLogoutRedirectUri", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityAlwaysColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ClientId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ClientId1")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("PostLogoutRedirectUri")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientId");
+
+                    b.HasIndex("ClientId1");
+
+                    b.ToTable("ClientPostLogoutRedirectUris");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientProperty", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityAlwaysColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ClientId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ClientId1")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientId");
+
+                    b.HasIndex("ClientId1");
+
+                    b.ToTable("ClientProperties");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientRedirectUri", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityAlwaysColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ClientId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("RedirectUri")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientId");
+
+                    b.ToTable("ClientRedirectUris");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientScope", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityAlwaysColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ClientId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Scope")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientId");
+
+                    b.ToTable("ClientScopes");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientSecret", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityAlwaysColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("ClientId")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("ClientId1")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("Expiration")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientId");
+
+                    b.HasIndex("ClientId1");
+
+                    b.ToTable("ClientSecrets");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.DeviceFlowCodes", b =>
+                {
+                    b.Property<string>("UserCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DeviceCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClientId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Data")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("Expiration")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("SessionId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubjectId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserCode", "DeviceCode");
+
+                    b.ToTable("DeviceFlowCodes");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResource", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<DateTime>("Created")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Emphasize")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("Enabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("NonEditable")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("Required")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("ShowInDiscoveryDocument")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime?>("Updated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("IdentityResources");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceClaim", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("IdentityResourceId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IdentityResourceId");
+
+                    b.ToTable("IdentityResourceClaims");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceProperty", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<int>("IdentityResourceId")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Key")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IdentityResourceId");
+
+                    b.ToTable("IdentityResourceProperties");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.PersistedGrant", b =>
+                {
+                    b.Property<string>("Key")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClientId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("ConsumedTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("CreationTime")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Data")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("Expiration")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("SessionId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SubjectId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Type")
+                        .HasColumnType("text");
+
+                    b.HasKey("Key");
+
+                    b.ToTable("PersistedGrants");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRole", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("NormalizedName")
+                        .IsUnique()
+                        .HasDatabaseName("RoleNameIndex");
+
+                    b.ToTable("AspNetRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetRoleClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("ClaimType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClaimValue")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserClaims", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderKey")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ProviderDisplayName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("LoginProvider", "ProviderKey");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("AspNetUserLogins", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("RoleId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "RoleId");
+
+                    b.HasIndex("RoleId");
+
+                    b.ToTable("AspNetUserRoles", (string)null);
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("LoginProvider")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Value")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId", "LoginProvider", "Name");
+
+                    b.ToTable("AspNetUserTokens", (string)null);
+                });
+
+            modelBuilder.Entity("Yavsc.Abstract.Identity.ClientProviderInfo", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Avatar")
+                        .HasColumnType("text");
+
+                    b.Property<long>("BillingAddressId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("EMail")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Phone")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId");
+
+                    b.ToTable("ClientProviderInfo");
+                });
+
+            modelBuilder.Entity("Yavsc.Abstract.Models.Messaging.Notification", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Target")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("body")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("click_action")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("color")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("icon")
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)")
+                        .HasDefaultValue("exclam");
+
+                    b.Property<string>("sound")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("tag")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<string>("title")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Notification");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Access.Ban", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("TargetId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserCreated")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserModified")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TargetId");
+
+                    b.ToTable("Ban");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Access.BlackListed", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("OwnerId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OwnerId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("BlackListed");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Access.CircleAuthorizationToBlogPost", b =>
+                {
+                    b.Property<long>("CircleId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("BlogPostId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("CircleId", "BlogPostId");
+
+                    b.HasIndex("BlogPostId");
+
+                    b.ToTable("CircleAuthorizationToBlogPost");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Access.CircleAuthorizationToFile", b =>
+                {
+                    b.Property<long>("CircleId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Path")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OwnerId")
+                        .HasColumnType("text");
+
+                    b.Property<byte>("Access")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("CircleId", "Path", "OwnerId");
+
+                    b.HasIndex("OwnerId");
+
+                    b.ToTable("CircleAuthorizationToFile");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.AccountBalance", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<long>("ContactCredits")
+                        .HasColumnType("bigint");
+
+                    b.Property<decimal>("Credits")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("UserId");
+
+                    b.ToTable("BankStatus");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.ApplicationUser", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<int>("AccessFailedCount")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("AllowMonthlyEmail")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Avatar")
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)")
+                        .HasDefaultValue("/images/Users/icon_user.png");
+
+                    b.Property<string>("ConcurrencyStamp")
+                        .IsConcurrencyToken()
+                        .HasColumnType("text");
+
+                    b.Property<string>("DedicatedGoogleCalendar")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<long>("DiskQuota")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint")
+                        .HasDefaultValue(524288000L);
+
+                    b.Property<long>("DiskUsage")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Email")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<bool>("EmailConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("FullName")
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<bool>("LockoutEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTimeOffset?>("LockoutEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long>("MaxFileSize")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("NormalizedEmail")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("NormalizedUserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("PasswordHash")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PhoneNumber")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("PhoneNumberConfirmed")
+                        .HasColumnType("boolean");
+
+                    b.Property<long?>("PostalAddressId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("SecurityStamp")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("TwoFactorEnabled")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserName")
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasAlternateKey("Email");
+
+                    b.HasIndex("NormalizedEmail")
+                        .HasDatabaseName("EmailIndex");
+
+                    b.HasIndex("NormalizedUserName")
+                        .IsUnique()
+                        .HasDatabaseName("UserNameIndex");
+
+                    b.HasIndex("PostalAddressId");
+
+                    b.ToTable("AspNetUsers", (string)null);
+                });
+
+            modelBuilder.Entity("Yavsc.Models.BalanceImpact", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("BalanceId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("ExecDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("Impact")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("BalanceId");
+
+                    b.ToTable("BalanceImpact");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Bank.BankIdentity", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("AccountNumber")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BIC")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("BankCode")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("BankedKey")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("IBAN")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("WicketCode")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("BankIdentity");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Billing.CommandLine", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Count")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Currency")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<long>("EstimateId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long?>("EstimateTemplateId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<decimal>("UnitaryCost")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("EstimateId");
+
+                    b.HasIndex("EstimateTemplateId");
+
+                    b.ToTable("CommandLine");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Billing.Estimate", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("AttachedFilesString")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AttachedGraphicsString")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClientId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("ClientValidationDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("CommandId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("CommandType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OwnerId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("ProviderValidationDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ClientId");
+
+                    b.HasIndex("CommandId");
+
+                    b.HasIndex("OwnerId");
+
+                    b.ToTable("Estimates");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Billing.EstimateAttachedFile", b =>
+                {
+                    b.Property<long>("FileId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("EstimateId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("FileId", "EstimateId");
+
+                    b.HasIndex("EstimateId");
+
+                    b.ToTable("EstimateAttachedFiles");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Billing.EstimateTemplate", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OwnerId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("EstimateTemplates");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Billing.ExceptionSIREN", b =>
+                {
+                    b.Property<string>("SIREN")
+                        .HasColumnType("text");
+
+                    b.HasKey("SIREN");
+
+                    b.ToTable("ExceptionsSIREN");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Billing.NominativeServiceCommand", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("ActivityCode")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ClientId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Consent")
+                        .HasColumnType("boolean");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Discriminator")
+                        .IsRequired()
+                        .HasMaxLength(34)
+                        .HasColumnType("character varying(34)");
+
+                    b.Property<string>("PaymentId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PerformerId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("Provisional")
+                        .HasColumnType("numeric");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("UserCreated")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserModified")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("ValidationDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ActivityCode");
+
+                    b.HasIndex("ClientId");
+
+                    b.HasIndex("PaymentId");
+
+                    b.HasIndex("PerformerId");
+
+                    b.ToTable("NominativeServiceCommands");
+
+                    b.HasDiscriminator<string>("Discriminator").HasValue("NominativeServiceCommand");
+
+                    b.UseTphMappingStrategy();
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Billing.QueryAttachedFile", b =>
+                {
+                    b.Property<long>("FileId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("CommandId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("FileId", "CommandId");
+
+                    b.HasIndex("CommandId");
+
+                    b.ToTable("QueryAttachedFiles");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Billing.Signature", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("CapturedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("CoordinateMax")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasDefaultValue(10000);
+
+                    b.Property<long>("EstimateId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("SignerId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.PrimitiveCollection<int[]>("Strokes")
+                        .IsRequired()
+                        .HasColumnType("integer[]");
+
+                    b.Property<int>("Type")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("SignerId");
+
+                    b.HasIndex("EstimateId", "Type")
+                        .IsUnique();
+
+                    b.ToTable("Signatures");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Blog.BlogAttachedFile", b =>
+                {
+                    b.Property<long>("FileId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("PostId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("FileId", "PostId");
+
+                    b.HasIndex("PostId");
+
+                    b.ToTable("BlogAttachedFiles");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Blog.BlogPost", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Article")
+                        .HasMaxLength(56224)
+                        .HasColumnType("character varying(56224)");
+
+                    b.Property<string>("AuthorId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Photo")
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasMaxLength(1024)
+                        .HasColumnType("character varying(1024)");
+
+                    b.Property<string>("UserCreated")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserModified")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AuthorId");
+
+                    b.ToTable("BlogSpot");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Blog.BlogTag", b =>
+                {
+                    b.Property<long>("PostId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("TagId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("PostId", "TagId");
+
+                    b.HasIndex("TagId");
+
+                    b.ToTable("BlogTag");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Blog.Comment", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Article")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("AuthorId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("ParentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("ReceiverId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("UserCreated")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserModified")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Visible")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("AuthorId");
+
+                    b.HasIndex("ParentId");
+
+                    b.HasIndex("ReceiverId");
+
+                    b.ToTable("Comment");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Blog.UploadedFile", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("ContentType")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("Length")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("OwnerId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OwnerId");
+
+                    b.ToTable("UploadedFiles");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.BlogSpotPublication", b =>
+                {
+                    b.Property<long>("PostId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("PostId");
+
+                    b.ToTable("blogSpotPublications");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Calendar.Schedule", b =>
+                {
+                    b.Property<string>("OwnerId")
+                        .HasColumnType("text");
+
+                    b.HasKey("OwnerId");
+
+                    b.ToTable("Schedule");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Calendar.ScheduledEvent", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime?>("PeriodEnd")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("PeriodStart")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<int>("Reccurence")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ScheduleOwnerId")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ScheduleOwnerId");
+
+                    b.HasIndex("PeriodStart", "PeriodEnd");
+
+                    b.ToTable("ScheduledEvent");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Chat.ChatConnection", b =>
+                {
+                    b.Property<string>("ConnectionId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ApplicationUserId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Connected")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("UserAgent")
+                        .HasColumnType("text");
+
+                    b.HasKey("ConnectionId");
+
+                    b.HasIndex("ApplicationUserId");
+
+                    b.ToTable("ChatConnection");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Chat.ChatRoom", b =>
+                {
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("LatestJoinPart")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("OwnerId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Topic")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserCreated")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserModified")
+                        .HasColumnType("text");
+
+                    b.HasKey("Name");
+
+                    b.HasIndex("OwnerId");
+
+                    b.ToTable("ChatRoom");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Chat.ChatRoomAccess", b =>
+                {
+                    b.Property<string>("ChannelName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Level")
+                        .HasColumnType("integer");
+
+                    b.HasKey("ChannelName", "UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("ChatRoomAccess");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Cratie.Option", b =>
+                {
+                    b.Property<string>("Code")
+                        .HasColumnType("text");
+
+                    b.Property<string>("CodeScrutin")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserCreated")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserModified")
+                        .HasColumnType("text");
+
+                    b.HasKey("Code", "CodeScrutin");
+
+                    b.ToTable("Option");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Drawing.Color", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<byte>("Blue")
+                        .HasColumnType("smallint");
+
+                    b.Property<byte>("Green")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<byte>("Red")
+                        .HasColumnType("smallint");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Color");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Haircut.BrusherProfile", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ActionDistance")
+                        .HasColumnType("integer");
+
+                    b.Property<decimal>("CarePrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("FlatFeeDiscount")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("HalfBalayagePrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("HalfBrushingPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("HalfColorPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("HalfDefrisPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("HalfFoldingPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("HalfMechPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("HalfMultiColorPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("HalfPermanentPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("KidCutPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("LongBalayagePrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("LongBrushingPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("LongColorPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("LongDefrisPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("LongFoldingPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("LongMechPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("LongMultiColorPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("LongPermanentPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("ManBrushPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("ManCutPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("ScheduleOwnerId")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("ShampooPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("ShortBalayagePrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("ShortBrushingPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("ShortColorPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("ShortDefrisPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("ShortFoldingPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("ShortMechPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("ShortMultiColorPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("ShortPermanentPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("WomenHalfCutPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("WomenLongCutPrice")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("WomenShortCutPrice")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("UserId");
+
+                    b.HasIndex("ScheduleOwnerId");
+
+                    b.ToTable("BrusherProfile");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Haircut.HairPrestation", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<bool>("Cares")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("Cut")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("Dressing")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Gender")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Length")
+                        .HasColumnType("integer");
+
+                    b.Property<bool>("Shampoo")
+                        .HasColumnType("boolean");
+
+                    b.Property<int>("Tech")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("HairPrestation");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Haircut.HairPrestationCollectionItem", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("PrestationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("QueryId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("PrestationId");
+
+                    b.HasIndex("QueryId");
+
+                    b.ToTable("HairPrestationCollectionItem");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Haircut.HairTaint", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Brand")
+                        .HasColumnType("text");
+
+                    b.Property<long>("ColorId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ColorId");
+
+                    b.ToTable("HairTaint");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Haircut.HairTaintInstance", b =>
+                {
+                    b.Property<long>("TaintId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("PrestationId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("TaintId", "PrestationId");
+
+                    b.HasIndex("PrestationId");
+
+                    b.ToTable("HairTaintInstance");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.IT.Evolution.Feature", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ShortName")
+                        .HasColumnType("text");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Feature");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.IT.Fixing.Bug", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Description")
+                        .IsRequired()
+                        .HasMaxLength(10240)
+                        .HasColumnType("character varying(10240)");
+
+                    b.Property<long?>("FeatureId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Title")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FeatureId");
+
+                    b.ToTable("Bug");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Identity.DeviceDeclaration", b =>
+                {
+                    b.Property<string>("DeviceId")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DeclarationDate")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("timestamp with time zone")
+                        .HasDefaultValueSql("LOCALTIMESTAMP");
+
+                    b.Property<string>("DeviceOwnerId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("LatestActivityUpdate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Model")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Platform")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Version")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("DeviceId");
+
+                    b.HasIndex("DeviceOwnerId");
+
+                    b.ToTable("DeviceDeclaration");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Kyc.DeclarationFlag", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("DeclarationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("MatchExcerpt")
+                        .HasMaxLength(100)
+                        .HasColumnType("character varying(100)");
+
+                    b.Property<int>("PatternId")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeclarationId");
+
+                    b.HasIndex("PatternId");
+
+                    b.ToTable("DeclarationFlag");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Kyc.ModerationLog", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<int>("Action")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("DeclarationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("ModeratorId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ScoreDelta")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("Timestamp")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DeclarationId");
+
+                    b.HasIndex("ModeratorId");
+
+                    b.HasIndex("Timestamp");
+
+                    b.ToTable("ModerationLogs", t =>
+                        {
+                            t.HasCheckConstraint("CK_ModerationLog_Immutable", "1=1");
+                        });
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Kyc.RegexAlertPattern", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<int>("Id"));
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<bool>("IsActive")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("Pattern")
+                        .IsRequired()
+                        .HasMaxLength(500)
+                        .HasColumnType("character varying(500)");
+
+                    b.Property<int>("Severity")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("IsActive");
+
+                    b.ToTable("RegexAlertPatterns");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Kyc.TrustDeclaration", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Content")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<Guid>("DeclarantTokenId")
+                        .HasColumnType("uuid");
+
+                    b.Property<int?>("ScoreDelta")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Sentiment")
+                        .HasColumnType("integer");
+
+                    b.Property<int>("Status")
+                        .HasColumnType("integer");
+
+                    b.Property<DateTime>("SubmittedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<Guid>("TrustTokenId")
+                        .HasColumnType("uuid");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("Status");
+
+                    b.HasIndex("SubmittedAt");
+
+                    b.HasIndex("TrustTokenId");
+
+                    b.ToTable("TrustDeclarations");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Kyc.TrustToken", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("uuid");
+
+                    b.Property<DateTime>("CreatedAt")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("TokenHash")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("TokenSource")
+                        .IsRequired()
+                        .HasMaxLength(32)
+                        .HasColumnType("character varying(32)");
+
+                    b.Property<int?>("TrustScore")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("TokenHash")
+                        .IsUnique();
+
+                    b.ToTable("TrustTokens");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Market.Product", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<decimal>("Depth")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<decimal>("Height")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<decimal?>("Price")
+                        .HasColumnType("numeric");
+
+                    b.Property<bool>("Public")
+                        .HasColumnType("boolean");
+
+                    b.Property<decimal>("Weight")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("Width")
+                        .HasColumnType("numeric");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Products");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Market.Service", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("ContextId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Public")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ContextId");
+
+                    b.ToTable("Services");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Messaging.Announce", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<byte>("For")
+                        .HasColumnType("smallint");
+
+                    b.Property<string>("Message")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OwnerId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Sender")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Topic")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OwnerId");
+
+                    b.ToTable("Announce");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Messaging.DismissClicked", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<long>("NotificationId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("UserId", "NotificationId");
+
+                    b.HasIndex("NotificationId");
+
+                    b.ToTable("DismissClicked");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Musical.Instrument", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Instrument");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Musical.InstrumentRating", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<long>("InstrumentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("OwnerId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int>("Rate")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.HasAlternateKey("InstrumentId", "OwnerId");
+
+                    b.HasIndex("OwnerId");
+
+                    b.ToTable("InstrumentRating");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Musical.MusicalPreference", b =>
+                {
+                    b.Property<string>("OwnerProfileId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DjSettingsUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MusicLoverSettingsUserId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("Rate")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("TendencyId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("OwnerProfileId");
+
+                    b.HasIndex("DjSettingsUserId");
+
+                    b.HasIndex("MusicLoverSettingsUserId");
+
+                    b.HasIndex("TendencyId");
+
+                    b.ToTable("MusicalPreference");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Musical.MusicalTendency", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MusicalTendency");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Musical.Profiles.DjSettings", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("SoundCloudId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId");
+
+                    b.ToTable("DjSettings");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Musical.Profiles.Instrumentation", b =>
+                {
+                    b.Property<long>("InstrumentId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.HasKey("InstrumentId", "UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("Instrumentation");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Musical.Profiles.MusicLoverSettings", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId");
+
+                    b.ToTable("MusicLoverSettings");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Payment.PayPalPayment", b =>
+                {
+                    b.Property<string>("CreationToken")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ExecutorId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OrderReference")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PaypalPayerId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("State")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserCreated")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserModified")
+                        .HasColumnType("text");
+
+                    b.HasKey("CreationToken");
+
+                    b.HasIndex("ExecutorId");
+
+                    b.ToTable("PayPalPayment");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Relationship.Circle", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("ApplicationUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OwnerId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Public")
+                        .HasColumnType("boolean");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ApplicationUserId");
+
+                    b.ToTable("Circle");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Relationship.CircleMember", b =>
+                {
+                    b.Property<string>("MemberId")
+                        .HasColumnType("text");
+
+                    b.Property<long>("CircleId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("MemberId", "CircleId");
+
+                    b.HasIndex("CircleId");
+
+                    b.ToTable("CircleMembers");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Relationship.Contact", b =>
+                {
+                    b.Property<string>("OwnerId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<long>("AddressId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("ApplicationUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("EMail")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.HasKey("OwnerId", "UserId");
+
+                    b.HasIndex("AddressId");
+
+                    b.HasIndex("ApplicationUserId");
+
+                    b.ToTable("Contact");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Relationship.HyperLink", b =>
+                {
+                    b.Property<string>("HRef")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Method")
+                        .HasColumnType("text");
+
+                    b.Property<string>("BrusherProfileUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ContentType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PayPalPaymentCreationToken")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Rel")
+                        .HasColumnType("text");
+
+                    b.HasKey("HRef", "Method");
+
+                    b.HasIndex("BrusherProfileUserId");
+
+                    b.HasIndex("PayPalPaymentCreationToken");
+
+                    b.ToTable("HyperLink");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Relationship.Location", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Address")
+                        .IsRequired()
+                        .HasMaxLength(512)
+                        .HasColumnType("character varying(512)");
+
+                    b.Property<double>("Latitude")
+                        .HasColumnType("double precision");
+
+                    b.Property<double>("Longitude")
+                        .HasColumnType("double precision");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Locations");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Relationship.PostalAddress", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("City")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Country")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PostalCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Province")
+                        .HasColumnType("text");
+
+                    b.Property<string>("State")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Street1")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Street2")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("PostalAddress");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Relationship.Tag", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("Tags");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.ResourceUsageRecord", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<decimal>("ApiCalls")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("BandwidthMb")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("CpuSeconds")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)")
+                        .HasDefaultValue("EUR");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("EstimatedCompensation")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("RecordedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("StorageMb")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("UserCreated")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("UserModified")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "RecordedAtUtc");
+
+                    b.ToTable("ResourceUsageRecords");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Skill", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Name")
+                        .HasColumnType("text");
+
+                    b.Property<int>("Rate")
+                        .HasColumnType("integer");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("SiteSkills");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Streaming.LiveFlow", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("DifferedFileName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("MediaType")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OwnerId")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Pitch")
+                        .HasColumnType("text");
+
+                    b.Property<int>("SequenceNumber")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OwnerId");
+
+                    b.ToTable("LiveFlow");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.Activity", b =>
+                {
+                    b.Property<string>("Code")
+                        .HasColumnType("text");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Description")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("Hidden")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("Moderated")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ModeratorGroupName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("ParentCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Photo")
+                        .HasColumnType("text");
+
+                    b.Property<int>("Rate")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SettingsClassName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserCreated")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserModified")
+                        .HasColumnType("text");
+
+                    b.HasKey("Code");
+
+                    b.HasIndex("ParentCode");
+
+                    b.ToTable("Activities");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.CoWorking", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("FormationSettingsUserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("PerformerId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("WorkingForId")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("FormationSettingsUserId");
+
+                    b.HasIndex("PerformerId");
+
+                    b.HasIndex("WorkingForId");
+
+                    b.ToTable("CoWorking");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.CommandForm", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("ActionName")
+                        .HasColumnType("text");
+
+                    b.Property<string>("ActivityCode")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Title")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ActivityCode");
+
+                    b.ToTable("CommandForm");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.Country", b =>
+                {
+                    b.Property<string>("Code")
+                        .HasMaxLength(2)
+                        .HasColumnType("character varying(2)");
+
+                    b.Property<string>("DisplayName")
+                        .IsRequired()
+                        .HasMaxLength(64)
+                        .HasColumnType("character varying(64)");
+
+                    b.HasKey("Code");
+
+                    b.ToTable("Countries");
+
+                    b.HasData(
+                        new
+                        {
+                            Code = "fr",
+                            DisplayName = "France"
+                        },
+                        new
+                        {
+                            Code = "en",
+                            DisplayName = "England"
+                        },
+                        new
+                        {
+                            Code = "pt",
+                            DisplayName = "Portugal"
+                        });
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.DictionnaireMetier", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("DomaineActiviteCode")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("Langue")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)");
+
+                    b.Property<string>("Nom")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("DomaineActiviteCode", "Langue", "Nom")
+                        .IsUnique();
+
+                    b.ToTable("DictionnaireMetier");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.PerformerCodeInputValidation", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("CountryCode")
+                        .IsRequired()
+                        .HasMaxLength(2)
+                        .HasColumnType("character varying(2)");
+
+                    b.Property<string>("ErrorMessage")
+                        .IsRequired()
+                        .HasMaxLength(128)
+                        .HasColumnType("character varying(128)");
+
+                    b.Property<string>("RegularExpression")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("CountryCode");
+
+                    b.ToTable("PerformerCodeInputValidations");
+
+                    b.HasData(
+                        new
+                        {
+                            Id = 1L,
+                            CountryCode = "fr",
+                            ErrorMessage = "Le code FR doit contenir entre 9 et 14 chiffres.",
+                            RegularExpression = "^[0-9]{9,14}$"
+                        },
+                        new
+                        {
+                            Id = 2L,
+                            CountryCode = "en",
+                            ErrorMessage = "Le code EN doit contenir entre 8 et 14 caracteres alphanumeriques.",
+                            RegularExpression = "^[A-Za-z0-9]{8,14}$"
+                        },
+                        new
+                        {
+                            Id = 3L,
+                            CountryCode = "pt",
+                            ErrorMessage = "Le code PT doit contenir exactement 9 chiffres.",
+                            RegularExpression = "^[0-9]{9}$"
+                        });
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.PerformerProfile", b =>
+                {
+                    b.Property<string>("PerformerId")
+                        .HasColumnType("text");
+
+                    b.Property<bool>("AcceptNotifications")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("AcceptPublicContact")
+                        .HasColumnType("boolean");
+
+                    b.Property<bool>("Active")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("ExerciseCountryCode")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<int?>("MaxDailyCost")
+                        .HasColumnType("integer");
+
+                    b.Property<int?>("MinDailyCost")
+                        .HasColumnType("integer");
+
+                    b.Property<long>("OrganizationAddressId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("Rate")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("SIREN")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<bool>("UseGeoLocalizationToReduceDistanceWithClients")
+                        .HasColumnType("boolean");
+
+                    b.Property<string>("WebSite")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasKey("PerformerId");
+
+                    b.HasIndex("OrganizationAddressId");
+
+                    b.ToTable("Performers");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.Profiles.FormationSettings", b =>
+                {
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("DisplayName")
+                        .HasColumnType("text");
+
+                    b.HasKey("UserId");
+
+                    b.ToTable("FormationSettings");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.TermeMetier", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<DateTime>("DateSoumission")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime?>("DateValidation")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("Definition")
+                        .IsRequired()
+                        .HasMaxLength(2000)
+                        .HasColumnType("character varying(2000)");
+
+                    b.Property<long>("DictionnaireMetierId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Langue")
+                        .IsRequired()
+                        .HasMaxLength(20)
+                        .HasColumnType("character varying(20)");
+
+                    b.Property<string>("Mot")
+                        .IsRequired()
+                        .HasMaxLength(200)
+                        .HasColumnType("character varying(200)");
+
+                    b.Property<string>("ProposeParId")
+                        .HasMaxLength(450)
+                        .HasColumnType("character varying(450)");
+
+                    b.Property<int>("StatutValidation")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("ValideParId")
+                        .HasMaxLength(450)
+                        .HasColumnType("character varying(450)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProposeParId");
+
+                    b.HasIndex("ValideParId");
+
+                    b.HasIndex("DictionnaireMetierId", "Langue", "Mot")
+                        .IsUnique();
+
+                    b.ToTable("TermeMetier");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.UserActivity", b =>
+                {
+                    b.Property<string>("DoesCode")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .HasColumnType("text");
+
+                    b.Property<int>("Weight")
+                        .HasColumnType("integer");
+
+                    b.HasKey("DoesCode", "UserId");
+
+                    b.HasIndex("UserId");
+
+                    b.ToTable("UserActivities");
+                });
+
+            modelBuilder.Entity("Yavsc.Server.Models.Calendar.Period", b =>
+                {
+                    b.Property<DateTime>("Start")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("End")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.HasKey("Start", "End");
+
+                    b.ToTable("Period");
+                });
+
+            modelBuilder.Entity("Yavsc.Server.Models.EMailing.MailingTemplate", b =>
+                {
+                    b.Property<string>("Id")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Body")
+                        .HasMaxLength(65536)
+                        .HasColumnType("character varying(65536)");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<string>("ReplyToAddress")
+                        .HasColumnType("text");
+
+                    b.Property<int>("ToSend")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Topic")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserCreated")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserModified")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("MailingTemplate");
+                });
+
+            modelBuilder.Entity("Yavsc.Server.Models.IT.ProjectBuildConfiguration", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<long>("ProjectId")
+                        .HasColumnType("bigint");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("ProjectId");
+
+                    b.ToTable("ProjectBuildConfiguration");
+                });
+
+            modelBuilder.Entity("Yavsc.Server.Models.IT.SourceCode.GitRepositoryReference", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<string>("Branch")
+                        .HasColumnType("text");
+
+                    b.Property<string>("OwnerId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Path")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("Url")
+                        .HasColumnType("text");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("OwnerId");
+
+                    b.ToTable("GitRepositoryReference");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Haircut.HairCutQuery", b =>
+                {
+                    b.HasBaseType("Yavsc.Models.Billing.NominativeServiceCommand");
+
+                    b.Property<string>("AdditionalInfo")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<DateTime?>("EventDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long?>("LocationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<long>("PrestationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("SelectedProfileUserId")
+                        .HasColumnType("text");
+
+                    b.HasIndex("LocationId");
+
+                    b.HasIndex("PrestationId");
+
+                    b.HasIndex("SelectedProfileUserId");
+
+                    b.HasDiscriminator().HasValue("HairCutQuery");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Haircut.HairMultiCutQuery", b =>
+                {
+                    b.HasBaseType("Yavsc.Models.Billing.NominativeServiceCommand");
+
+                    b.Property<DateTime>("EventDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long>("LocationId")
+                        .HasColumnType("bigint");
+
+                    b.HasIndex("LocationId");
+
+                    b.ToTable("NominativeServiceCommands", t =>
+                        {
+                            t.Property("EventDate")
+                                .HasColumnName("HairMultiCutQuery_EventDate");
+
+                            t.Property("LocationId")
+                                .HasColumnName("HairMultiCutQuery_LocationId");
+                        });
+
+                    b.HasDiscriminator().HasValue("HairMultiCutQuery");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.RdvQuery", b =>
+                {
+                    b.HasBaseType("Yavsc.Models.Billing.NominativeServiceCommand");
+
+                    b.Property<DateTime>("EventDate")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<long>("LocationId")
+                        .HasColumnType("bigint");
+
+                    b.Property<int>("LocationType")
+                        .HasColumnType("integer");
+
+                    b.Property<string>("Reason")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.HasIndex("LocationId");
+
+                    b.ToTable("NominativeServiceCommands", t =>
+                        {
+                            t.Property("EventDate")
+                                .HasColumnName("RdvQuery_EventDate");
+
+                            t.Property("LocationId")
+                                .HasColumnName("RdvQuery_LocationId");
+                        });
+
+                    b.HasDiscriminator().HasValue("RdvQuery");
+                });
+
+            modelBuilder.Entity("Yavsc.Server.Models.IT.Project", b =>
+                {
+                    b.HasBaseType("Yavsc.Models.Billing.NominativeServiceCommand");
+
+                    b.Property<long>("GitId")
+                        .HasColumnType("bigint");
+
+                    b.Property<string>("Name")
+                        .IsRequired()
+                        .HasColumnType("text");
+
+                    b.Property<string>("OwnerId")
+                        .HasColumnType("text");
+
+                    b.Property<string>("Version")
+                        .HasColumnType("text");
+
+                    b.HasIndex("GitId");
+
+                    b.HasDiscriminator().HasValue("Project");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceClaim", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", null)
+                        .WithMany("UserClaims")
+                        .HasForeignKey("ApiResourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
+                        .WithMany()
+                        .HasForeignKey("ApiResourceId1");
+
+                    b.Navigation("ApiResource");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceProperty", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", null)
+                        .WithMany("Properties")
+                        .HasForeignKey("ApiResourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
+                        .WithMany()
+                        .HasForeignKey("ApiResourceId1");
+
+                    b.Navigation("ApiResource");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceScope", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", null)
+                        .WithMany("Scopes")
+                        .HasForeignKey("ApiResourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
+                        .WithMany()
+                        .HasForeignKey("ApiResourceId1");
+
+                    b.Navigation("ApiResource");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResourceSecret", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", null)
+                        .WithMany("Secrets")
+                        .HasForeignKey("ApiResourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiResource", "ApiResource")
+                        .WithMany()
+                        .HasForeignKey("ApiResourceId1");
+
+                    b.Navigation("ApiResource");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeClaim", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiScope", null)
+                        .WithMany("UserClaims")
+                        .HasForeignKey("ScopeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiScope", "Scope")
+                        .WithMany()
+                        .HasForeignKey("ScopeId1");
+
+                    b.Navigation("Scope");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScopeProperty", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiScope", null)
+                        .WithMany("Properties")
+                        .HasForeignKey("ScopeId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.ApiScope", "Scope")
+                        .WithMany()
+                        .HasForeignKey("ScopeId1");
+
+                    b.Navigation("Scope");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientClaim", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
+                        .WithMany("Claims")
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Client");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientCorsOrigin", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", null)
+                        .WithMany("AllowedCorsOrigins")
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
+                        .WithMany()
+                        .HasForeignKey("ClientId1");
+
+                    b.Navigation("Client");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientGrantType", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
+                        .WithMany("AllowedGrantTypes")
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Client");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientIdPRestriction", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", null)
+                        .WithMany("IdentityProviderRestrictions")
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
+                        .WithMany()
+                        .HasForeignKey("ClientId1");
+
+                    b.Navigation("Client");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientPostLogoutRedirectUri", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", null)
+                        .WithMany("PostLogoutRedirectUris")
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
+                        .WithMany()
+                        .HasForeignKey("ClientId1");
+
+                    b.Navigation("Client");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientProperty", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", null)
+                        .WithMany("Properties")
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
+                        .WithMany()
+                        .HasForeignKey("ClientId1");
+
+                    b.Navigation("Client");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientRedirectUri", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
+                        .WithMany("RedirectUris")
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Client");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientScope", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
+                        .WithMany("AllowedScopes")
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Client");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ClientSecret", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", null)
+                        .WithMany("ClientSecrets")
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.Client", "Client")
+                        .WithMany()
+                        .HasForeignKey("ClientId1");
+
+                    b.Navigation("Client");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceClaim", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.IdentityResource", "IdentityResource")
+                        .WithMany("UserClaims")
+                        .HasForeignKey("IdentityResourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("IdentityResource");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResourceProperty", b =>
+                {
+                    b.HasOne("IdentityServer8.EntityFramework.Entities.IdentityResource", "IdentityResource")
+                        .WithMany("Properties")
+                        .HasForeignKey("IdentityResourceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("IdentityResource");
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityRoleClaim<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserClaim<string>", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserLogin<string>", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserRole<string>", b =>
+                {
+                    b.HasOne("Microsoft.AspNetCore.Identity.IdentityRole", null)
+                        .WithMany()
+                        .HasForeignKey("RoleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Microsoft.AspNetCore.Identity.IdentityUserToken<string>", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", null)
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Access.Ban", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", "TargetUser")
+                        .WithMany()
+                        .HasForeignKey("TargetId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TargetUser");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Access.BlackListed", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Owner")
+                        .WithMany("BlackList")
+                        .HasForeignKey("OwnerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.ApplicationUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Owner");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Access.CircleAuthorizationToBlogPost", b =>
+                {
+                    b.HasOne("Yavsc.Models.Blog.BlogPost", "Target")
+                        .WithMany("ACL")
+                        .HasForeignKey("BlogPostId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.Relationship.Circle", "Allowed")
+                        .WithMany()
+                        .HasForeignKey("CircleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Allowed");
+
+                    b.Navigation("Target");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Access.CircleAuthorizationToFile", b =>
+                {
+                    b.HasOne("Yavsc.Models.Relationship.Circle", "Allowed")
+                        .WithMany()
+                        .HasForeignKey("CircleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Allowed");
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.AccountBalance", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Owner")
+                        .WithOne("AccountBalance")
+                        .HasForeignKey("Yavsc.Models.AccountBalance", "UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.ApplicationUser", b =>
+                {
+                    b.HasOne("Yavsc.Models.Relationship.Location", "PostalAddress")
+                        .WithMany()
+                        .HasForeignKey("PostalAddressId");
+
+                    b.Navigation("PostalAddress");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.BalanceImpact", b =>
+                {
+                    b.HasOne("Yavsc.Models.AccountBalance", "Balance")
+                        .WithMany()
+                        .HasForeignKey("BalanceId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Balance");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Bank.BankIdentity", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", "User")
+                        .WithMany("BankInfo")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Billing.CommandLine", b =>
+                {
+                    b.HasOne("Yavsc.Models.Billing.Estimate", null)
+                        .WithMany("Bill")
+                        .HasForeignKey("EstimateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.Billing.EstimateTemplate", null)
+                        .WithMany("Bill")
+                        .HasForeignKey("EstimateTemplateId");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Billing.Estimate", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Client")
+                        .WithMany()
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.Billing.NominativeServiceCommand", "Query")
+                        .WithMany()
+                        .HasForeignKey("CommandId");
+
+                    b.HasOne("Yavsc.Models.Workflow.PerformerProfile", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Client");
+
+                    b.Navigation("Owner");
+
+                    b.Navigation("Query");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Billing.EstimateAttachedFile", b =>
+                {
+                    b.HasOne("Yavsc.Models.Billing.Estimate", "Estimate")
+                        .WithMany()
+                        .HasForeignKey("EstimateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.Blog.UploadedFile", "File")
+                        .WithMany()
+                        .HasForeignKey("FileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Estimate");
+
+                    b.Navigation("File");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Billing.NominativeServiceCommand", b =>
+                {
+                    b.HasOne("Yavsc.Models.Workflow.Activity", "Context")
+                        .WithMany()
+                        .HasForeignKey("ActivityCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Client")
+                        .WithMany()
+                        .HasForeignKey("ClientId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.Payment.PayPalPayment", "Regularization")
+                        .WithMany()
+                        .HasForeignKey("PaymentId");
+
+                    b.HasOne("Yavsc.Models.Workflow.PerformerProfile", "PerformerProfile")
+                        .WithMany()
+                        .HasForeignKey("PerformerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Client");
+
+                    b.Navigation("Context");
+
+                    b.Navigation("PerformerProfile");
+
+                    b.Navigation("Regularization");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Billing.QueryAttachedFile", b =>
+                {
+                    b.HasOne("Yavsc.Models.Billing.NominativeServiceCommand", "Command")
+                        .WithMany()
+                        .HasForeignKey("CommandId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.Blog.UploadedFile", "File")
+                        .WithMany()
+                        .HasForeignKey("FileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Command");
+
+                    b.Navigation("File");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Billing.Signature", b =>
+                {
+                    b.HasOne("Yavsc.Models.Billing.Estimate", "Estimate")
+                        .WithMany("Signatures")
+                        .HasForeignKey("EstimateId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Signer")
+                        .WithMany()
+                        .HasForeignKey("SignerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Estimate");
+
+                    b.Navigation("Signer");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Blog.BlogAttachedFile", b =>
+                {
+                    b.HasOne("Yavsc.Models.Blog.UploadedFile", "File")
+                        .WithMany()
+                        .HasForeignKey("FileId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.Blog.BlogPost", "Post")
+                        .WithMany()
+                        .HasForeignKey("PostId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("File");
+
+                    b.Navigation("Post");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Blog.BlogPost", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Author")
+                        .WithMany("Posts")
+                        .HasForeignKey("AuthorId")
+                        .OnDelete(DeleteBehavior.Restrict);
+
+                    b.Navigation("Author");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Blog.BlogTag", b =>
+                {
+                    b.HasOne("Yavsc.Models.Blog.BlogPost", "Post")
+                        .WithMany("Tags")
+                        .HasForeignKey("PostId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.Relationship.Tag", "Tag")
+                        .WithMany()
+                        .HasForeignKey("TagId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Post");
+
+                    b.Navigation("Tag");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Blog.Comment", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Author")
+                        .WithMany("BlogComments")
+                        .HasForeignKey("AuthorId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.Blog.Comment", "Parent")
+                        .WithMany("Children")
+                        .HasForeignKey("ParentId");
+
+                    b.HasOne("Yavsc.Models.Blog.BlogPost", "Post")
+                        .WithMany("Comments")
+                        .HasForeignKey("ReceiverId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Author");
+
+                    b.Navigation("Parent");
+
+                    b.Navigation("Post");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Blog.UploadedFile", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerId");
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.BlogSpotPublication", b =>
+                {
+                    b.HasOne("Yavsc.Models.Blog.BlogPost", "Post")
+                        .WithOne("Publication")
+                        .HasForeignKey("Yavsc.Models.BlogSpotPublication", "PostId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Post");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Calendar.Schedule", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Calendar.ScheduledEvent", b =>
+                {
+                    b.HasOne("Yavsc.Models.Calendar.Schedule", null)
+                        .WithMany("Events")
+                        .HasForeignKey("ScheduleOwnerId");
+
+                    b.HasOne("Yavsc.Server.Models.Calendar.Period", "Period")
+                        .WithMany()
+                        .HasForeignKey("PeriodStart", "PeriodEnd");
+
+                    b.Navigation("Period");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Chat.ChatConnection", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Owner")
+                        .WithMany("Connections")
+                        .HasForeignKey("ApplicationUserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Chat.ChatRoom", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Owner")
+                        .WithMany("Rooms")
+                        .HasForeignKey("OwnerId");
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Chat.ChatRoomAccess", b =>
+                {
+                    b.HasOne("Yavsc.Models.Chat.ChatRoom", "Room")
+                        .WithMany("Moderation")
+                        .HasForeignKey("ChannelName")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.ApplicationUser", "User")
+                        .WithMany("RoomAccess")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Room");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Haircut.BrusherProfile", b =>
+                {
+                    b.HasOne("Yavsc.Models.Calendar.Schedule", "Schedule")
+                        .WithMany()
+                        .HasForeignKey("ScheduleOwnerId");
+
+                    b.HasOne("Yavsc.Models.Workflow.PerformerProfile", "BaseProfile")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("BaseProfile");
+
+                    b.Navigation("Schedule");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Haircut.HairPrestationCollectionItem", b =>
+                {
+                    b.HasOne("Yavsc.Models.Haircut.HairPrestation", "Prestation")
+                        .WithMany()
+                        .HasForeignKey("PrestationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.Haircut.HairMultiCutQuery", "Query")
+                        .WithMany("Prestations")
+                        .HasForeignKey("QueryId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Prestation");
+
+                    b.Navigation("Query");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Haircut.HairTaint", b =>
+                {
+                    b.HasOne("Yavsc.Models.Drawing.Color", "Color")
+                        .WithMany()
+                        .HasForeignKey("ColorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Color");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Haircut.HairTaintInstance", b =>
+                {
+                    b.HasOne("Yavsc.Models.Haircut.HairPrestation", "Prestation")
+                        .WithMany("Taints")
+                        .HasForeignKey("PrestationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.Haircut.HairTaint", "Taint")
+                        .WithMany()
+                        .HasForeignKey("TaintId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Prestation");
+
+                    b.Navigation("Taint");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.IT.Fixing.Bug", b =>
+                {
+                    b.HasOne("Yavsc.Models.IT.Evolution.Feature", "False")
+                        .WithMany()
+                        .HasForeignKey("FeatureId");
+
+                    b.Navigation("False");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Identity.DeviceDeclaration", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", "DeviceOwner")
+                        .WithMany("DeviceDeclaration")
+                        .HasForeignKey("DeviceOwnerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("DeviceOwner");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Kyc.DeclarationFlag", b =>
+                {
+                    b.HasOne("Yavsc.Models.Kyc.TrustDeclaration", "Declaration")
+                        .WithMany("Flags")
+                        .HasForeignKey("DeclarationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.Kyc.RegexAlertPattern", "Pattern")
+                        .WithMany()
+                        .HasForeignKey("PatternId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Declaration");
+
+                    b.Navigation("Pattern");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Kyc.ModerationLog", b =>
+                {
+                    b.HasOne("Yavsc.Models.Kyc.TrustDeclaration", "Declaration")
+                        .WithMany()
+                        .HasForeignKey("DeclarationId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Declaration");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Kyc.TrustDeclaration", b =>
+                {
+                    b.HasOne("Yavsc.Models.Kyc.TrustToken", "Subject")
+                        .WithMany("Declarations")
+                        .HasForeignKey("TrustTokenId")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Subject");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Market.Service", b =>
+                {
+                    b.HasOne("Yavsc.Models.Workflow.Activity", "Context")
+                        .WithMany("Services")
+                        .HasForeignKey("ContextId");
+
+                    b.Navigation("Context");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Messaging.Announce", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerId");
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Messaging.DismissClicked", b =>
+                {
+                    b.HasOne("Yavsc.Abstract.Models.Messaging.Notification", "Notified")
+                        .WithMany()
+                        .HasForeignKey("NotificationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.ApplicationUser", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Notified");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Musical.InstrumentRating", b =>
+                {
+                    b.HasOne("Yavsc.Models.Musical.Instrument", "Instrument")
+                        .WithMany()
+                        .HasForeignKey("InstrumentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.Workflow.PerformerProfile", "Profile")
+                        .WithMany()
+                        .HasForeignKey("OwnerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Instrument");
+
+                    b.Navigation("Profile");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Musical.MusicalPreference", b =>
+                {
+                    b.HasOne("Yavsc.Models.Musical.Profiles.DjSettings", null)
+                        .WithMany("SoundColor")
+                        .HasForeignKey("DjSettingsUserId");
+
+                    b.HasOne("Yavsc.Models.Musical.Profiles.MusicLoverSettings", null)
+                        .WithMany("SoundColor")
+                        .HasForeignKey("MusicLoverSettingsUserId");
+
+                    b.HasOne("Yavsc.Models.Musical.MusicalTendency", "MusicalTendency")
+                        .WithMany()
+                        .HasForeignKey("TendencyId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("MusicalTendency");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Musical.Profiles.Instrumentation", b =>
+                {
+                    b.HasOne("Yavsc.Models.Musical.Instrument", "Tool")
+                        .WithMany()
+                        .HasForeignKey("InstrumentId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.Workflow.PerformerProfile", "User")
+                        .WithMany()
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Tool");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Payment.PayPalPayment", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Executor")
+                        .WithMany()
+                        .HasForeignKey("ExecutorId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Executor");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Relationship.Circle", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", null)
+                        .WithMany("Circles")
+                        .HasForeignKey("ApplicationUserId");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Relationship.CircleMember", b =>
+                {
+                    b.HasOne("Yavsc.Models.Relationship.Circle", "Circle")
+                        .WithMany("Members")
+                        .HasForeignKey("CircleId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Member")
+                        .WithMany("Membership")
+                        .HasForeignKey("MemberId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Circle");
+
+                    b.Navigation("Member");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Relationship.Contact", b =>
+                {
+                    b.HasOne("Yavsc.Models.Relationship.PostalAddress", "PostalAddress")
+                        .WithMany()
+                        .HasForeignKey("AddressId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.ApplicationUser", null)
+                        .WithMany("Book")
+                        .HasForeignKey("ApplicationUserId");
+
+                    b.Navigation("PostalAddress");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Relationship.HyperLink", b =>
+                {
+                    b.HasOne("Yavsc.Models.Haircut.BrusherProfile", null)
+                        .WithMany("Links")
+                        .HasForeignKey("BrusherProfileUserId");
+
+                    b.HasOne("Yavsc.Models.Payment.PayPalPayment", null)
+                        .WithMany("Links")
+                        .HasForeignKey("PayPalPaymentCreationToken");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Streaming.LiveFlow", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.Activity", b =>
+                {
+                    b.HasOne("Yavsc.Models.Workflow.Activity", "Parent")
+                        .WithMany("Children")
+                        .HasForeignKey("ParentCode");
+
+                    b.Navigation("Parent");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.CoWorking", b =>
+                {
+                    b.HasOne("Yavsc.Models.Workflow.Profiles.FormationSettings", null)
+                        .WithMany("CoWorking")
+                        .HasForeignKey("FormationSettingsUserId");
+
+                    b.HasOne("Yavsc.Models.Workflow.PerformerProfile", "Performer")
+                        .WithMany()
+                        .HasForeignKey("PerformerId");
+
+                    b.HasOne("Yavsc.Models.ApplicationUser", "WorkingFor")
+                        .WithMany()
+                        .HasForeignKey("WorkingForId");
+
+                    b.Navigation("Performer");
+
+                    b.Navigation("WorkingFor");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.CommandForm", b =>
+                {
+                    b.HasOne("Yavsc.Models.Workflow.Activity", "Context")
+                        .WithMany("Forms")
+                        .HasForeignKey("ActivityCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Context");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.DictionnaireMetier", b =>
+                {
+                    b.HasOne("Yavsc.Models.Workflow.Activity", "DomaineActivite")
+                        .WithMany()
+                        .HasForeignKey("DomaineActiviteCode")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("DomaineActivite");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.PerformerCodeInputValidation", b =>
+                {
+                    b.HasOne("Yavsc.Models.Workflow.Country", "Country")
+                        .WithMany()
+                        .HasForeignKey("CountryCode")
+                        .OnDelete(DeleteBehavior.Restrict)
+                        .IsRequired();
+
+                    b.Navigation("Country");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.PerformerProfile", b =>
+                {
+                    b.HasOne("Yavsc.Models.Relationship.Location", "OrganizationAddress")
+                        .WithMany()
+                        .HasForeignKey("OrganizationAddressId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Performer")
+                        .WithMany()
+                        .HasForeignKey("PerformerId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("OrganizationAddress");
+
+                    b.Navigation("Performer");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.TermeMetier", b =>
+                {
+                    b.HasOne("Yavsc.Models.Workflow.DictionnaireMetier", "DictionnaireMetier")
+                        .WithMany("Termes")
+                        .HasForeignKey("DictionnaireMetierId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.ApplicationUser", "ProposePar")
+                        .WithMany()
+                        .HasForeignKey("ProposeParId");
+
+                    b.HasOne("Yavsc.Models.ApplicationUser", "ValidePar")
+                        .WithMany()
+                        .HasForeignKey("ValideParId");
+
+                    b.Navigation("DictionnaireMetier");
+
+                    b.Navigation("ProposePar");
+
+                    b.Navigation("ValidePar");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.UserActivity", b =>
+                {
+                    b.HasOne("Yavsc.Models.Workflow.Activity", "Does")
+                        .WithMany()
+                        .HasForeignKey("DoesCode")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.Workflow.PerformerProfile", "User")
+                        .WithMany("Activity")
+                        .HasForeignKey("UserId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Does");
+
+                    b.Navigation("User");
+                });
+
+            modelBuilder.Entity("Yavsc.Server.Models.IT.ProjectBuildConfiguration", b =>
+                {
+                    b.HasOne("Yavsc.Server.Models.IT.Project", "TargetProject")
+                        .WithMany("Configurations")
+                        .HasForeignKey("ProjectId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("TargetProject");
+                });
+
+            modelBuilder.Entity("Yavsc.Server.Models.IT.SourceCode.GitRepositoryReference", b =>
+                {
+                    b.HasOne("Yavsc.Models.ApplicationUser", "Owner")
+                        .WithMany()
+                        .HasForeignKey("OwnerId");
+
+                    b.Navigation("Owner");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Haircut.HairCutQuery", b =>
+                {
+                    b.HasOne("Yavsc.Models.Relationship.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId");
+
+                    b.HasOne("Yavsc.Models.Haircut.HairPrestation", "Prestation")
+                        .WithMany()
+                        .HasForeignKey("PrestationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("Yavsc.Models.Haircut.BrusherProfile", "SelectedProfile")
+                        .WithMany()
+                        .HasForeignKey("SelectedProfileUserId");
+
+                    b.Navigation("Location");
+
+                    b.Navigation("Prestation");
+
+                    b.Navigation("SelectedProfile");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Haircut.HairMultiCutQuery", b =>
+                {
+                    b.HasOne("Yavsc.Models.Relationship.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.RdvQuery", b =>
+                {
+                    b.HasOne("Yavsc.Models.Relationship.Location", "Location")
+                        .WithMany()
+                        .HasForeignKey("LocationId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Location");
+                });
+
+            modelBuilder.Entity("Yavsc.Server.Models.IT.Project", b =>
+                {
+                    b.HasOne("Yavsc.Server.Models.IT.SourceCode.GitRepositoryReference", "Repository")
+                        .WithMany()
+                        .HasForeignKey("GitId")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("Repository");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiResource", b =>
+                {
+                    b.Navigation("Properties");
+
+                    b.Navigation("Scopes");
+
+                    b.Navigation("Secrets");
+
+                    b.Navigation("UserClaims");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.ApiScope", b =>
+                {
+                    b.Navigation("Properties");
+
+                    b.Navigation("UserClaims");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.Client", b =>
+                {
+                    b.Navigation("AllowedCorsOrigins");
+
+                    b.Navigation("AllowedGrantTypes");
+
+                    b.Navigation("AllowedScopes");
+
+                    b.Navigation("Claims");
+
+                    b.Navigation("ClientSecrets");
+
+                    b.Navigation("IdentityProviderRestrictions");
+
+                    b.Navigation("PostLogoutRedirectUris");
+
+                    b.Navigation("Properties");
+
+                    b.Navigation("RedirectUris");
+                });
+
+            modelBuilder.Entity("IdentityServer8.EntityFramework.Entities.IdentityResource", b =>
+                {
+                    b.Navigation("Properties");
+
+                    b.Navigation("UserClaims");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.ApplicationUser", b =>
+                {
+                    b.Navigation("AccountBalance");
+
+                    b.Navigation("BankInfo");
+
+                    b.Navigation("BlackList");
+
+                    b.Navigation("BlogComments");
+
+                    b.Navigation("Book");
+
+                    b.Navigation("Circles");
+
+                    b.Navigation("Connections");
+
+                    b.Navigation("DeviceDeclaration");
+
+                    b.Navigation("Membership");
+
+                    b.Navigation("Posts");
+
+                    b.Navigation("RoomAccess");
+
+                    b.Navigation("Rooms");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Billing.Estimate", b =>
+                {
+                    b.Navigation("Bill");
+
+                    b.Navigation("Signatures");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Billing.EstimateTemplate", b =>
+                {
+                    b.Navigation("Bill");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Blog.BlogPost", b =>
+                {
+                    b.Navigation("ACL");
+
+                    b.Navigation("Comments");
+
+                    b.Navigation("Publication")
+                        .IsRequired();
+
+                    b.Navigation("Tags");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Blog.Comment", b =>
+                {
+                    b.Navigation("Children");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Calendar.Schedule", b =>
+                {
+                    b.Navigation("Events");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Chat.ChatRoom", b =>
+                {
+                    b.Navigation("Moderation");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Haircut.BrusherProfile", b =>
+                {
+                    b.Navigation("Links");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Haircut.HairPrestation", b =>
+                {
+                    b.Navigation("Taints");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Kyc.TrustDeclaration", b =>
+                {
+                    b.Navigation("Flags");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Kyc.TrustToken", b =>
+                {
+                    b.Navigation("Declarations");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Musical.Profiles.DjSettings", b =>
+                {
+                    b.Navigation("SoundColor");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Musical.Profiles.MusicLoverSettings", b =>
+                {
+                    b.Navigation("SoundColor");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Payment.PayPalPayment", b =>
+                {
+                    b.Navigation("Links");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Relationship.Circle", b =>
+                {
+                    b.Navigation("Members");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.Activity", b =>
+                {
+                    b.Navigation("Children");
+
+                    b.Navigation("Forms");
+
+                    b.Navigation("Services");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.DictionnaireMetier", b =>
+                {
+                    b.Navigation("Termes");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.PerformerProfile", b =>
+                {
+                    b.Navigation("Activity");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Workflow.Profiles.FormationSettings", b =>
+                {
+                    b.Navigation("CoWorking");
+                });
+
+            modelBuilder.Entity("Yavsc.Models.Haircut.HairMultiCutQuery", b =>
+                {
+                    b.Navigation("Prestations");
+                });
+
+            modelBuilder.Entity("Yavsc.Server.Models.IT.Project", b =>
+                {
+                    b.Navigation("Configurations");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}
diff --git a/src/Yavsc.Org/Migrations/20261007011348_ResourceUsageRecords.cs b/src/Yavsc.Org/Migrations/20261007011348_ResourceUsageRecords.cs
new file mode 100644
index 000000000..0108acad4
--- /dev/null
+++ b/src/Yavsc.Org/Migrations/20261007011348_ResourceUsageRecords.cs
@@ -0,0 +1,53 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace Yavsc.Migrations
+{
+    /// <inheritdoc />
+    public partial class ResourceUsageRecords : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "ResourceUsageRecords",
+                columns: table => new
+                {
+                    Id = table.Column<long>(type: "bigint", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    UserId = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    UserName = table.Column<string>(type: "character varying(256)", maxLength: 256, nullable: false),
+                    RecordedAtUtc = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    ApiCalls = table.Column<decimal>(type: "numeric", nullable: false),
+                    CpuSeconds = table.Column<decimal>(type: "numeric", nullable: false),
+                    BandwidthMb = table.Column<decimal>(type: "numeric", nullable: false),
+                    StorageMb = table.Column<decimal>(type: "numeric", nullable: false),
+                    EstimatedCompensation = table.Column<decimal>(type: "numeric", nullable: false),
+                    Currency = table.Column<string>(type: "character varying(8)", maxLength: 8, nullable: false, defaultValue: "EUR"),
+                    DateCreated = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    UserCreated = table.Column<string>(type: "text", nullable: true),
+                    DateModified = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    UserModified = table.Column<string>(type: "text", nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_ResourceUsageRecords", x => x.Id);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_ResourceUsageRecords_UserId_RecordedAtUtc",
+                table: "ResourceUsageRecords",
+                columns: new[] { "UserId", "RecordedAtUtc" });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "ResourceUsageRecords");
+        }
+    }
+}
diff --git a/src/Yavsc.Org/Migrations/ApplicationDbContextModelSnapshot.cs b/src/Yavsc.Org/Migrations/ApplicationDbContextModelSnapshot.cs
index 711408cd4..fc4909c4c 100644
--- a/src/Yavsc.Org/Migrations/ApplicationDbContextModelSnapshot.cs
+++ b/src/Yavsc.Org/Migrations/ApplicationDbContextModelSnapshot.cs
@@ -2821,6 +2821,68 @@ namespace Yavsc.Migrations
                     b.ToTable("Tags");
                 });
 
+            modelBuilder.Entity("Yavsc.Models.ResourceUsageRecord", b =>
+                {
+                    b.Property<long>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("bigint");
+
+                    NpgsqlPropertyBuilderExtensions.UseIdentityByDefaultColumn(b.Property<long>("Id"));
+
+                    b.Property<decimal>("ApiCalls")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("BandwidthMb")
+                        .HasColumnType("numeric");
+
+                    b.Property<decimal>("CpuSeconds")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("Currency")
+                        .IsRequired()
+                        .ValueGeneratedOnAdd()
+                        .HasMaxLength(8)
+                        .HasColumnType("character varying(8)")
+                        .HasDefaultValue("EUR");
+
+                    b.Property<DateTime>("DateCreated")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<DateTime>("DateModified")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("EstimatedCompensation")
+                        .HasColumnType("numeric");
+
+                    b.Property<DateTime>("RecordedAtUtc")
+                        .HasColumnType("timestamp with time zone");
+
+                    b.Property<decimal>("StorageMb")
+                        .HasColumnType("numeric");
+
+                    b.Property<string>("UserCreated")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserId")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.Property<string>("UserModified")
+                        .HasColumnType("text");
+
+                    b.Property<string>("UserName")
+                        .IsRequired()
+                        .HasMaxLength(256)
+                        .HasColumnType("character varying(256)");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserId", "RecordedAtUtc");
+
+                    b.ToTable("ResourceUsageRecords");
+                });
+
             modelBuilder.Entity("Yavsc.Models.Skill", b =>
                 {
                     b.Property<long>("Id")
diff --git a/src/Yavsc.Server/Helpers/ResourceUsageTelemetryMiddleware.cs b/src/Yavsc.Server/Helpers/ResourceUsageTelemetryMiddleware.cs
new file mode 100644
index 000000000..8b1795167
--- /dev/null
+++ b/src/Yavsc.Server/Helpers/ResourceUsageTelemetryMiddleware.cs
@@ -0,0 +1,54 @@
+#nullable enable
+using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.DependencyInjection;
+using Yavsc.Models;
+
+namespace Yavsc.Server.Helpers;
+
+public sealed class ResourceUsageTelemetryMiddleware
+{
+    private readonly RequestDelegate _next;
+    private readonly IServiceScopeFactory _scopeFactory;
+
+    public ResourceUsageTelemetryMiddleware(
+        RequestDelegate next,
+        IServiceScopeFactory scopeFactory)
+    {
+        _next = next;
+        _scopeFactory = scopeFactory;
+    }
+
+    public async Task InvokeAsync(HttpContext context)
+    {
+        var userId = context.User.GetUserId();
+        if (string.IsNullOrWhiteSpace(userId))
+        {
+            await _next(context);
+            return;
+        }
+
+        var userName = context.User.Identity?.Name ?? userId;
+        var requestBytes = context.Request.ContentLength ?? 0L;
+
+        try
+        {
+            await _next(context);
+        }
+        finally
+        {
+            var responseBytes = context.Response.ContentLength ?? 0L;
+            var totalBytes = requestBytes + responseBytes;
+            var bandwidthMb = totalBytes <= 0 ? 0m : (decimal)totalBytes / (1024m * 1024m);
+
+            using var scope = _scopeFactory.CreateScope();
+            var db = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
+            await ResourceUsageTracker.RecordAsync(
+                db,
+                userId,
+                userName,
+                apiCalls: 1m,
+                bandwidthMb: bandwidthMb,
+                actorUserId: userId);
+        }
+    }
+}
diff --git a/src/Yavsc.Server/Helpers/ResourceUsageTracker.cs b/src/Yavsc.Server/Helpers/ResourceUsageTracker.cs
new file mode 100644
index 000000000..cad05a699
--- /dev/null
+++ b/src/Yavsc.Server/Helpers/ResourceUsageTracker.cs
@@ -0,0 +1,69 @@
+#nullable enable
+using Microsoft.EntityFrameworkCore;
+using Yavsc.Models;
+
+namespace Yavsc.Server.Helpers;
+
+public static class ResourceUsageTracker
+{
+    public static async Task RecordAsync(
+        ApplicationDbContext dbContext,
+        string userId,
+        string userName,
+        decimal cpuSeconds = 0m,
+        long storageBytes = 0,
+        decimal apiCalls = 0m,
+        decimal bandwidthMb = 0m,
+        string? actorUserId = null,
+        string currency = Constants.ResourceUsageDefaultCurrency)
+    {
+        if (dbContext is null || string.IsNullOrWhiteSpace(userId))
+        {
+            return;
+        }
+
+        var effectiveActor = string.IsNullOrWhiteSpace(actorUserId) ? userId : actorUserId;
+        var now = DateTime.UtcNow;
+        var storageMb = storageBytes <= 0 ? 0m : (decimal)storageBytes / (1024m * 1024m);
+
+        var record = await dbContext.ResourceUsageRecords
+            .Where(r => r.UserId == userId)
+            .OrderByDescending(r => r.RecordedAtUtc)
+            .FirstOrDefaultAsync();
+
+        if (record is null)
+        {
+            record = new ResourceUsageRecord
+            {
+                UserId = userId,
+                UserName = string.IsNullOrWhiteSpace(userName) ? userId : userName,
+                RecordedAtUtc = now,
+                ApiCalls = apiCalls,
+                CpuSeconds = cpuSeconds,
+                BandwidthMb = bandwidthMb,
+                StorageMb = storageMb,
+                EstimatedCompensation = 0m,
+                Currency = currency,
+                UserCreated = effectiveActor,
+                UserModified = effectiveActor,
+                DateCreated = now,
+                DateModified = now,
+            };
+            dbContext.ResourceUsageRecords.Add(record);
+            await dbContext.SaveChangesAsync(effectiveActor);
+            return;
+        }
+
+        record.UserName = string.IsNullOrWhiteSpace(userName) ? record.UserName : userName;
+        record.RecordedAtUtc = now;
+        record.ApiCalls += apiCalls;
+        record.CpuSeconds += cpuSeconds;
+        record.BandwidthMb += bandwidthMb;
+        record.StorageMb += storageMb;
+        record.Currency = string.IsNullOrWhiteSpace(currency) ? record.Currency : currency;
+        record.DateModified = now;
+        record.UserModified = effectiveActor;
+
+        await dbContext.SaveChangesAsync(effectiveActor);
+    }
+}
diff --git a/src/Yavsc.Server/Models/ApplicationDbContext.cs b/src/Yavsc.Server/Models/ApplicationDbContext.cs
index 85ed8f8d9..ef5f2db6e 100644
--- a/src/Yavsc.Server/Models/ApplicationDbContext.cs
+++ b/src/Yavsc.Server/Models/ApplicationDbContext.cs
@@ -58,6 +58,14 @@ namespace Yavsc.Models
             }
             builder.UseIdentityByDefaultColumns();
 
+            builder.Entity<ResourceUsageRecord>(entity =>
+            {
+                entity.HasKey(r => r.Id);
+                entity.HasIndex(r => new { r.UserId, r.RecordedAtUtc });
+                entity.Property(r => r.Currency).HasMaxLength(8).HasDefaultValue(Constants.ResourceUsageDefaultCurrency);
+                entity.Property(r => r.UserName).HasMaxLength(256);
+            });
+
             // Customize the ASP.NET Identity model and override the defaults if needed.
             // For example, you can rename the ASP.NET Identity table names and more.
             // Add your customizations after calling base.OnModelCreating(builder);
@@ -324,6 +332,7 @@ namespace Yavsc.Models
 
         public DbSet<Estimate> Estimates { get; set; }
         public DbSet<Signature> Signatures { get; set; }
+        public DbSet<ResourceUsageRecord> ResourceUsageRecords { get; set; }
         public DbSet<AccountBalance> BankStatus { get; set; }
         public DbSet<BalanceImpact> BalanceImpact { get; set; }
 
diff --git a/src/Yavsc.Server/Models/ResourceUsageRecord.cs b/src/Yavsc.Server/Models/ResourceUsageRecord.cs
new file mode 100644
index 000000000..4b8a8794d
--- /dev/null
+++ b/src/Yavsc.Server/Models/ResourceUsageRecord.cs
@@ -0,0 +1,36 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace Yavsc.Models;
+
+public sealed class ResourceUsageRecord : ITrackedEntity
+{
+    [Key]
+    public long Id { get; set; }
+
+    [Required]
+    [MaxLength(256)]
+    public string UserId { get; set; } = string.Empty;
+
+    [Required]
+    [MaxLength(256)]
+    public string UserName { get; set; } = string.Empty;
+
+    [Required]
+    public DateTime RecordedAtUtc { get; set; } = DateTime.UtcNow;
+
+    public decimal ApiCalls { get; set; }
+    public decimal CpuSeconds { get; set; }
+    public decimal BandwidthMb { get; set; }
+    public decimal StorageMb { get; set; }
+    public decimal EstimatedCompensation { get; set; }
+
+    [Required]
+    [MaxLength(8)]
+    public string Currency { get; set; } = Constants.ResourceUsageDefaultCurrency;
+
+    public DateTime DateCreated { get; set; } = DateTime.UtcNow;
+    public string UserCreated { get; set; } = string.Empty;
+    public DateTime DateModified { get; set; } = DateTime.UtcNow;
+    public string UserModified { get; set; } = string.Empty;
+}
diff --git a/src/Yavsc.Server/ViewModels/Account/Me.cs b/src/Yavsc.Server/ViewModels/Account/Me.cs
index dad3ab01e..7cfae01b7 100644
--- a/src/Yavsc.Server/ViewModels/Account/Me.cs
+++ b/src/Yavsc.Server/ViewModels/Account/Me.cs
@@ -3,7 +3,7 @@ using Yavsc.Abstract.Identity;
 namespace Yavsc.Models.Auth
 {
     public class Me : IApplicationUser {
-        public Me(string userId, string userName, string email, string avatar, ILocation address, string gCalId)
+        public Me(string userId, string userName, string email, string avatar, ILocation address, string gCalId, string? fullName = null)
         {
            Id = userId;
            UserName = userName;
@@ -11,10 +11,14 @@ namespace Yavsc.Models.Auth
            Avatar = avatar;
            PostalAddress = address;
            DedicatedGoogleCalendar = gCalId;
+           FullName = fullName ?? string.Empty;
+           Address = address?.Address ?? string.Empty;
         }
         public string Id { get;  set; }
         public string UserName { get; set; }
+        public string FullName { get; set; }
         public string EMail { get; set; }
+        public string Address { get; set; }
         public string[] Roles { get; set; }
         /// <summary>
         /// Known as profile, could point to an avatar
@@ -24,18 +28,18 @@ namespace Yavsc.Models.Auth
 
         public IAccountBalance AccountBalance
         {
-            get; set; 
+            get; set;
         }
 
         public string DedicatedGoogleCalendar
         {
-            get; set; 
+            get; set;
         }
 
         public ILocation PostalAddress
         {
-            get; set; 
+            get; set;
         }
     }
 
-}
\ No newline at end of file
+}
diff --git a/src/test/Yavsc.Api.Tests/Fixtures/ApiWebServerFixture.cs b/src/test/Yavsc.Api.Tests/Fixtures/ApiWebServerFixture.cs
index 5d040fd27..875efb249 100644
--- a/src/test/Yavsc.Api.Tests/Fixtures/ApiWebServerFixture.cs
+++ b/src/test/Yavsc.Api.Tests/Fixtures/ApiWebServerFixture.cs
@@ -66,7 +66,14 @@ public sealed class ApiWebServerFixture : WebHostFixture
         builder.Services.Configure<GoogleAuthSettings>(_ => { });
         builder.Services.AddTransient<IBillingService, BillingService>();
         builder.Services.AddTransient<IYavscMessageSender, NoopMessageSender>();
-        builder.Services.AddAuthorization();
+        builder.Services.AddAuthorization(options =>
+        {
+            options.AddPolicy("AdministratorOnly", policy =>
+            {
+                policy.RequireAuthenticatedUser();
+                policy.RequireClaim(Yavsc.Constants.RoleClaimType, Yavsc.Constants.AdminGroupName);
+            });
+        });
 
         builder.Services.AddAuthentication("Bearer")
             .AddJwtBearer("Bearer", options =>
diff --git a/src/test/Yavsc.Api.Tests/ResourceUsageApiControllerTests.cs b/src/test/Yavsc.Api.Tests/ResourceUsageApiControllerTests.cs
new file mode 100644
index 000000000..8b8347aae
--- /dev/null
+++ b/src/test/Yavsc.Api.Tests/ResourceUsageApiControllerTests.cs
@@ -0,0 +1,124 @@
+using System.Net;
+using System.Net.Http.Headers;
+using System.Net.Http.Json;
+using System.Security.Claims;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Yavsc.Abstract.Resources;
+using Yavsc.Api.Test.Fixtures;
+using Yavsc.Server.Helpers;
+using Yavsc.Tests.Shared;
+
+namespace Yavsc.Api.Test;
+
+[Collection("Yavsc Api")]
+public sealed class ResourceUsageApiControllerTests : IClassFixture<ApiWebServerFixture>
+{
+    private readonly ApiWebServerFixture _fixture;
+
+    public ResourceUsageApiControllerTests(ApiWebServerFixture fixture)
+    {
+        _fixture = fixture;
+    }
+
+    private static HttpClient NewClient(ApiWebServerFixture fixture, string subject = "alice", string scope = "api", IEnumerable<Claim>? extraClaims = null)
+    {
+        var handler = new HttpClientHandler
+        {
+            ServerCertificateCustomValidationCallback = (_, _, _, _) => true
+        };
+
+        var http = new HttpClient(handler)
+        {
+            BaseAddress = new Uri(fixture.BaseAddress)
+        };
+
+        http.DefaultRequestHeaders.Authorization =
+            new AuthenticationHeaderValue("Bearer", TestTokenIssuer.Issue(subject, scope, extraClaims: extraClaims));
+
+        return http;
+    }
+
+    [Fact]
+    public async Task GetCurrentUserUsage_persists_snapshot_in_database()
+    {
+        using var http = NewClient(_fixture, "alice");
+
+        var response = await http.GetAsync("/api/v1/resource-usage/me", TestContext.Current.CancellationToken);
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+        var summary = await response.Content.ReadFromJsonAsync<ResourceUsageSummary>(TestContext.Current.CancellationToken);
+        Assert.NotNull(summary);
+        Assert.Equal("alice", summary!.UserId);
+
+        using var scope = _fixture.Services.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<Yavsc.Models.ApplicationDbContext>();
+        Assert.Contains(db.ResourceUsageRecords, r => r.UserId == "alice");
+    }
+
+    [Fact]
+    public async Task RecordAsync_persists_cpu_and_storage_usage()
+    {
+        using var scope = _fixture.Services.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<Yavsc.Models.ApplicationDbContext>();
+
+        await ResourceUsageTracker.RecordAsync(
+            db,
+            "alice",
+            "alice",
+            cpuSeconds: 1.5m,
+            storageBytes: 2 * 1024 * 1024,
+            actorUserId: "alice");
+
+        var record = await db.ResourceUsageRecords
+            .SingleAsync(r => r.UserId == "alice");
+
+        Assert.True(record.CpuSeconds >= 1.5m);
+        Assert.True(record.StorageMb >= 2m / 1024m / 1024m);
+    }
+
+    [Fact]
+    public async Task RecordAsync_persists_api_and_bandwidth_usage()
+    {
+        using var scope = _fixture.Services.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<Yavsc.Models.ApplicationDbContext>();
+
+        await ResourceUsageTracker.RecordAsync(
+            db,
+            "telemetry-user",
+            "telemetry-user",
+            apiCalls: 2m,
+            bandwidthMb: 3.5m,
+            actorUserId: "telemetry-user");
+
+        var record = await db.ResourceUsageRecords
+            .SingleAsync(r => r.UserId == "telemetry-user");
+
+        Assert.True(record.ApiCalls >= 2m);
+        Assert.True(record.BandwidthMb >= 3.5m);
+    }
+
+    [Fact]
+    public async Task GetAdminOverview_returns_latest_usage_snapshot_for_each_user()
+    {
+        using var http = NewClient(_fixture, "alice");
+        var first = await http.GetAsync("/api/v1/resource-usage/me", TestContext.Current.CancellationToken);
+        Assert.Equal(HttpStatusCode.OK, first.StatusCode);
+
+        using var adminHttp = NewClient(
+            _fixture,
+            "admin-user",
+            "api",
+            new[]
+            {
+                new Claim(Yavsc.Constants.RoleClaimType, Yavsc.Constants.AdminGroupName)
+            });
+
+        var response = await adminHttp.GetAsync("/api/v1/resource-usage/admin", TestContext.Current.CancellationToken);
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+
+        var payload = await response.Content.ReadFromJsonAsync<List<ResourceUsageSummary>>(TestContext.Current.CancellationToken);
+        Assert.NotNull(payload);
+        Assert.Contains(payload!, item => item.UserId == "alice");
+    }
+}