Case_accounting/CaseAccounting/CaseAccountingDataBaseImplement/Models/Lawyer.cs

using CaseAccountingContracts.BindingModels;
using CaseAccountingContracts.ViewModels;
using CaseAccountingDataModels.Models;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace CaseAccountingDataBaseImplement.Models
{
    public class Lawyer : ILawyerModel
    {
        public int Id { get; set; }

        [Required]
        public string Name { get; set; } = string.Empty;

        [Required]
        public string Surname { get; set; } = string.Empty;

        [Required]
        public string Patronymic { get; set; } = string.Empty;

        [Required]
        public int Experience { get; set; }

        [Required]
        public int SpecializationId { get; set; }
        public virtual Specialization Specialization { get; set; } = new();

        [Required]
        public int UserId { get; set; }
        public virtual User User { get; set; } = new();

        [ForeignKey("LawyerId")]
        public virtual List<CaseLawyer> CaseLawyers { get; set; } = new();

        [ForeignKey("LawyerId")]
        public virtual List<LawyerContract> LawyerContracts { get; set; } = new();

        private Dictionary<int, IContractModel>? _contracts;

        [NotMapped]
        public Dictionary<int, IContractModel> Contracts
        {
            get
            {
                if (_contracts == null)
                {
                    _contracts = LawyerContracts.ToDictionary(
                        x => x.ContractId, x => x.Contract as IContractModel);
                }
                return _contracts;
            }
        }

        public static Lawyer? Create(LawyerBindingModel? model)
        {
            if (model == null)
            {
                return null;
            }
            return new Lawyer()
            {
                Id = model.Id,
                Name = model.Name,
                Surname = model.Surname,
                Patronymic = model.Patronymic,
                Experience = model.Experience,
                SpecializationId = model.SpecializationId,
                UserId = model.UserId
            };
        }

        public void Update(LawyerBindingModel? model)
        {
            if (model == null)
            {
                return;
            }
            Name = model.Name;
            Surname = model.Surname;
            Patronymic = model.Patronymic;
            Experience = model.Experience;
            SpecializationId = model.SpecializationId;
        }

        public void UpdateContracts(CaseAccountingDatabase context, LawyerBindingModel model)
        {
            var lawyerContracts = context.LawyerContracts
                .Where(x => x.LawyerId == model.Id)
                .ToList();
            if (lawyerContracts != null)
            {
                context.LawyerContracts
                    .RemoveRange(lawyerContracts
                            .Where(x => !model.Contracts
                            .ContainsKey(x.ContractId))
                        );
                context.SaveChanges();
                var lawyer = context.Lawyers
                    .First(x => x.Id == Id);
                foreach (var lc in lawyerContracts)
                {
                    model.Contracts.Remove(lc.ContractId);
                }
                foreach (var lc in model.Contracts)
                {
                    context.LawyerContracts.Add(new LawyerContract
                    {
                        Lawyer = lawyer,
                        Contract = context.Contracts.First(x => x.Id == lc.Key),
                    });
                    context.SaveChanges();
                }
                _contracts = null;
            }
        }

        public LawyerViewModel GetViewModel => new()
        {
            Id = Id,
            Name = Name,
            Surname = Surname,
            Patronymic = Patronymic,
            Experience = Experience,
            SpecializationId = SpecializationId,
            UserId = UserId
        };
    }
}