FlexitimeTracker/FlexitimeUI/Flexitime.DataAccess/EF/FlexitimeDbContext.cs

using System;
using System.Collections.Generic;
using System.Linq;
using Flexitime.DataAccess.Objects;
using Flexitime.Interfaces;
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.Metadata.Builders;

namespace Flexitime.DataAccess.EF
{
    public class FlexitimeDbContext : DbContext
    {
        private readonly IConnectionStringProvider _connectionStringProvider;

        public FlexitimeDbContext(IConnectionStringProvider connectionStringProvider)
        {
            _connectionStringProvider = connectionStringProvider;
        }

        public DbSet<UserDb> Users { get; set; }
        public DbSet<TimeLogDb> TimeLogs { get; set; }
        public DbSet<IdentifierDb> Identifiers { get; set; }
        public DbSet<ApplicationDb> Applications { get; set; }
        public DbSet<GroupDb> Groups { get; set; }
        public DbSet<TeamDb> Teams { get; set; }
        public DbSet<LogSourceDescriptorDb> LogSources { get; set; }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlServer(_connectionStringProvider.ConnectionString);
        }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
            modelBuilder.ApplyConfiguration(new UserMap());
            modelBuilder.ApplyConfiguration(new IdentifierMap());

            base.OnModelCreating(modelBuilder);
        }

        public void InsertBaseData()
        {
            AddAdminUser();
            AddRootApplication();
        }

        private void AddRootApplication()
        {
            var systemApp = new ApplicationDb
            {
                Id = Guid.NewGuid(),
                Name = "System",
                Permissions = new List<PermissionDb>
                    {
                        CreatePermission("Add/Edit User", "s.u.e"),
                        CreatePermission("Delete User", "s.u.d"),
                        CreatePermission("Add/Edit Group", "s.g.e"),
                        CreatePermission("Delete Group", "s.g.d"),
                        CreatePermission("Associate Identifier", "s.i.e")
                    }
            };
            var existingSystemApp = Applications.Where(x => x.Name == "System")
                                                .Include(x=>x.Permissions)
                                                .FirstOrDefault();
            if (existingSystemApp == null)
            {
                Applications.Add(systemApp);

                var adminUser = Users.FirstOrDefault(x => x.UserName == "admin");
                adminUser?.Permissions.AddRange(systemApp.Permissions);

                SaveChanges();
            }
            else
            {
                var missingPermissions = systemApp.Permissions
                                                    .Where(x=> existingSystemApp.Permissions.All(y => y.Tag != x.Tag))
                                                    .ToList();
                if (missingPermissions.Any())
                {
                    existingSystemApp.Permissions.AddRange(missingPermissions);
                    Applications.Update(existingSystemApp);
                    SaveChanges();
                }
            }
        }

        private PermissionDb CreatePermission(string name, string tag)
        {
            return new()
            {
                Id = Guid.NewGuid(),
                Name = name,
                Tag = tag
            };
        }

        private void AddAdminUser()
        {
            if (!Users.Any())
            {
                Users.Add(new UserDb
                {
                    Id = Guid.NewGuid(),
                    FirstName = "Admin",
                    LastName = "Admin",
                    Password = "P@ssw0rd!",
                    UserName = "admin"
                });
                SaveChanges();
            }
        }
    }

    public class UserMap : IEntityTypeConfiguration<UserDb>
    {
        public void Configure(EntityTypeBuilder<UserDb> builder)
        {
            builder.ToTable("UserDb")
                .HasKey(x => x.Id);

            builder
                .HasOne(x => x.LineManager)
                .WithOne().OnDelete(DeleteBehavior.ClientSetNull);

            builder
                .HasOne(x => x.Team)
                .WithOne();

            builder
                .HasMany(x => x.AssociatedIdentifiers)
                .WithOne().OnDelete(DeleteBehavior.Cascade);
        }
    }

    public class IdentifierMap : IEntityTypeConfiguration<IdentifierDb>
    {
        public void Configure(EntityTypeBuilder<IdentifierDb> builder)
        {
            builder.ToTable("IdentifierDb")
                .HasKey(x => x.Id);
        }
    }

    public class TimeLogsMap : IEntityTypeConfiguration<TimeLogDb>
    {
        public void Configure(EntityTypeBuilder<TimeLogDb> builder)
        {
            builder.ToTable("TimeLogDb")
                .HasKey(x => x.Id);
        }
    }
}