Rogashova_E.A._CourseWork_Hospital/HospitalDataBaseImplements/Models/Recipes.cs

using HospitalContracts.BindingModels;
using HospitalContracts.ViewModels;
using HospitalDataModels.Models;
using Microsoft.EntityFrameworkCore.Query.Internal;
using Microsoft.Identity.Client;
using System;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using System.Dynamic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace HospitalDataBaseImplements.Models
{
    public class Recipes : IRecipesModel
    {
        public int Id { get; private set; }
        [Required]
        public string Dose { get; private set; } = string.Empty;
        [Required]
        public DateTime Date { get; private set; } = DateTime.Now;
        public int ClientId { get; set; }
        public virtual Medicines Medicines { get; set; } = new();
        public int MedicinesId { get; private set; }
        [Required]
        public string ModeOfApplication { get; private set; } = string.Empty;
        public Client Client { get; set; }
        private Dictionary<int, IProceduresModel>? _recipeProcedures = null;
        [NotMapped]
        public Dictionary<int, IProceduresModel> RecipeProcedures
        {
            get
            {
                if (_recipeProcedures == null)
                {
                    _recipeProcedures = Procedures.ToDictionary(recPC => recPC.ProcedureId, recPC =>
                    recPC.Procedure as IProceduresModel);
                }
                return _recipeProcedures;
            }
        }
        [ForeignKey("RecipesId")]
        public virtual List<RecipesProcedures> Procedures { get; set; } = new();

        //private Dictionary<int, ISymptomsModel>? _recipeSymptoms = null;
        //[NotMapped]
        //public Dictionary<int, ISymptomsModel> RecipeSymptoms
        //{
        //    get
        //    {
        //        if (_recipeSymptoms == null)
        //        {
        //            _recipeSymptoms = Symptoms.ToDictionary(recPC => recPC.SymptomsId, recPC => (recPC.Symptoms as ISymptomsModel));
        //        }
        //        return _recipeSymptoms;
        //    }
        //}
        //public virtual List<RecipesSymptoms> Symptoms { get; set; } = new();

        public static Recipes? Create(RecipesBindingModel model)
        {
            return new Recipes()
            {
                Id = model.Id,
                Dose = model.Dose,
                Date = model.Date,
                ModeOfApplication = model.ModeOfApplication,
                ClientId = model.ClientId
                //Symptoms = model.RecipeSymptoms.Select(x => new RecipesSymptoms
                //{
                //    Symptoms = context.Symptomses.First(y => y.Id == x.Key),
                //}).ToList()
            };
        }
        public void Update(RecipesBindingModel model)
        {
            Date = model.Date;
            MedicinesId = model.MedicinesId;
        }
        public RecipesViewModel GetViewModel
        {
            get
            {
                using var context = new HospitalDatabase();
                return new RecipesViewModel
                {
                    Id = Id,
                    Date = Date,
                    ClientId = ClientId,
                    ClientFIO = context.Clients.FirstOrDefault(x => x.Id == ClientId)?.ClientFIO ?? string.Empty,
                    MedicinesId = MedicinesId,
                    RecipeProcedures = RecipeProcedures,
                    //RecipeSymptoms = RecipeSymptoms
                };
            }
        }
        public void UpdateProcedures(HospitalDatabase context, RecipesBindingModel model)
        {
            var recipeProcedures = context.RecipesProcedures.Where(rec => rec.RecipesId == model.Id).ToList();
            if (recipeProcedures != null && recipeProcedures.Count > 0)
            { // удалили те, которых нет в модели
                context.RecipesProcedures.RemoveRange(recipeProcedures.Where(rec
               => !model.RecipeProcedures.ContainsKey(rec.ProcedureId)));
                context.SaveChanges();
            }
            var recipe = context.Recipes.First(x => x.Id == Id);
            foreach (var pc in model.RecipeProcedures)
            {
                context.RecipesProcedures.Add(new RecipesProcedures
                {
                    Recipe = recipe,
                    Procedure = context.Procedures.First(x => x.Id == pc.Key)
                });
                context.SaveChanges();
            }
            _recipeProcedures = null;
        }
        //public void UpdateSymptomses(HospitalDatabase context, RecipesBindingModel model)
        //{
        //    var recipeSymptomses = context.RecipesSymptoms.Where(rec => rec.RecipesId == model.Id).ToList();
        //    if (recipeSymptomses != null && recipeSymptomses.Count > 0)
        //    { // удалили те, которых нет в модели
        //        context.RecipesSymptoms.RemoveRange(recipeSymptomses.Where(rec
        //       => !model.RecipeSymptoms.ContainsKey(rec.SymptomsId)));
        //        context.SaveChanges();
        //    }
        //    var recipe = context.Recipes.First(x => x.Id == Id);
        //    foreach (var pc in model.RecipeSymptoms)
        //    {
        //        context.RecipesSymptoms.Add(new RecipesSymptoms
        //        {
        //            Recipe = recipe,
        //            Symptoms = context.Symptomses.First(x => x.Id == pc.Key)
        //        });
        //        context.SaveChanges();
        //    }
        //    _recipeSymptoms = null;
        //}
    }
}