add DatabaseImplement (Storage and Models)

Factory/FactoryContracts/BindingModels/MachineBindingModel.cs

@@ -14,6 +14,6 @@ namespace FactoryContracts.BindingModels
 
         public int ClientId { get; set; }
 
-        public Dictionary<int, (IPlanProductionModel, int)> PlanProductionMachines { get; set; } = new();
+        public Dictionary<int, (IPlanProductionModel, int)> MachinePlanProductions { get; set; } = new();
     }
 }

Factory/FactoryContracts/BindingModels/PlanProductionBindingModel.cs

@@ -12,7 +12,7 @@ namespace FactoryContracts.BindingModels
 
         public int Count { get; set; }
 
-        public DateTime Term { get; set; }
+        public DateTime Deadline { get; set; }
 
         public Dictionary<int, (IWorkpieceModel, int)> PlanProductionWorkpieces { get; set; } = new();
     }

Factory/FactoryContracts/SearchModels/MachineSearchModel.cs

@@ -4,6 +4,6 @@
     {
         public int? Id { get; set; }
 
-        public string? Name { get; set; }
+        public string? MachineName { get; set; }
     }
 }

Factory/FactoryContracts/SearchModels/ProductSearchModel.cs

@@ -4,6 +4,6 @@
     {
         public int? Id { get; set; }
 
-        public string? Name { get; set; }
+        public string? ProductName { get; set; }
     }
 }

Factory/FactoryContracts/SearchModels/RequirementSearchModel.cs

@@ -4,6 +4,6 @@
     {
         public int? Id { get; set; }
 
-        public string? Name { get; set; }
+        public string? RequirementName { get; set; }
     }
 }

Factory/FactoryContracts/ViewModels/MachineViewModel.cs

@@ -22,6 +22,6 @@ namespace FactoryContracts.ViewModels
         public string ClientLogin { get; set; } = string.Empty;
 
         [DisplayName("Планы производства")]
-        public Dictionary<int, (IPlanProductionModel, int)> PlanProductionMachines { get; set; } = new();
+        public Dictionary<int, (IPlanProductionModel, int)> MachinePlanProductions { get; set; } = new();
     }
 }

Factory/FactoryContracts/ViewModels/PlanProductionViewModel.cs

@@ -18,7 +18,7 @@ namespace FactoryContracts.ViewModels
         [DisplayName("Количество")]
         public int Count { get; set; }
         [DisplayName("Срок выполнения")]
-        public DateTime Term { get; set; }
+        public DateTime Deadline { get; set; }
         [DisplayName("Заготовки")]
         public Dictionary<int, (IWorkpieceModel, int)> PlanProductionWorkpieces { get; set; } = new();
     }

Factory/FactoryDataModels/Models/IMachineModel.cs

@@ -10,6 +10,6 @@
 
         int ClientId { get; }
 
-        Dictionary<int, (IPlanProductionModel, int)> PlanProductionMachines { get; }
+        Dictionary<int, (IPlanProductionModel, int)> MachinePlanProductions { get; }
     }
 }

Factory/FactoryDataModels/Models/IPlanProductionModel.cs

@@ -10,7 +10,7 @@
 
         int Count { get; }
 
-        DateTime Term { get; }
+        DateTime Deadline { get; }
 
         Dictionary<int, (IWorkpieceModel, int)> PlanProductionWorkpieces { get; }
     }

Factory/FactoryDatabaseImplement/FactoryDatabase.cs

@@ -9,11 +9,13 @@ namespace FactoryDatabaseImplement
         {
             if (optionsBuilder.IsConfigured == false)
             {
-                optionsBuilder.UseNpgsql(@"Host=localhost;Database=Factory;Username=postgres; Password = postgres");
+                optionsBuilder.UseNpgsql(@"Host=localhost;Database=Factory;Username=postgres;Password = postgres");
             }
             base.OnConfiguring(optionsBuilder);
-        }
 
+            AppContext.SetSwitch("Npgsql.EnableLegacyTimestampBehavior", true);
+            AppContext.SetSwitch("Npgsql.DisableDataTimeInfinityConversions", true);
+        }
         public virtual DbSet<Client> Clients { set; get; }
         public virtual DbSet<ExecutionPhase> ExecutionPhases { set; get; }
         public virtual DbSet<MachinePlanProduction> MachinePlanProductions { set; get; }
@@ -21,9 +23,9 @@ namespace FactoryDatabaseImplement
         public virtual DbSet<PlanProductionWorkpiece> PlanProductionWorkpieces { set; get; }
         public virtual DbSet<Workpiece> Workpieces { set; get; }
         public virtual DbSet<WorkpieceProduct> WorkpieceProducts { set; get; }
-
-       
-      
-      
+        public virtual DbSet<Machine> Machines { set; get; }
+        public virtual DbSet<ProductMachine> ProductMachines { set; get; }
+        public virtual DbSet<Product> Products { set; get; }
+        public virtual DbSet<Requirement> Requirements { set; get; }
     }
 }

Factory/FactoryDatabaseImplement/Implements/ExecutionPhaseStorage.cs

@@ -3,6 +3,7 @@ using FactoryContracts.SearchModels;
 using FactoryContracts.StoragesContracts;
 using FactoryContracts.ViewModels;
 using FactoryDatabaseImplement.Models;
+using Microsoft.EntityFrameworkCore;
 
 namespace FactoryDatabaseImplement.Implements
 {
@@ -12,6 +13,7 @@ namespace FactoryDatabaseImplement.Implements
         {
             using var context = new FactoryDatabase();
             return context.ExecutionPhases
+                .Include(x => x.Client)
                     .Select(x => x.GetViewModel)
                     .ToList();
         }
@@ -24,6 +26,7 @@ namespace FactoryDatabaseImplement.Implements
             }
             using var context = new FactoryDatabase();
             return context.ExecutionPhases
+                .Include(x => x.Client)
                     .Where(x => x.ExecutionPhaseName.Contains(model.ExecutionPhaseName))
                     .Select(x => x.GetViewModel)
                     .ToList();
@@ -36,7 +39,7 @@ namespace FactoryDatabaseImplement.Implements
                 return null;
             }
             using var context = new FactoryDatabase();
-            return context.ExecutionPhases
+            return context.ExecutionPhases.Include(x => x.Client)
                     .FirstOrDefault(x => (!string.IsNullOrEmpty(model.ExecutionPhaseName) && x.ExecutionPhaseName == model.ExecutionPhaseName) ||
                                         (model.Id.HasValue && x.Id == model.Id))
                     ?.GetViewModel;
@@ -71,7 +74,7 @@ namespace FactoryDatabaseImplement.Implements
         public ExecutionPhaseViewModel? Delete(ExecutionPhaseBindingModel model)
         {
             using var context = new FactoryDatabase();
-            var element = context.ExecutionPhases.FirstOrDefault(rec => rec.Id == model.Id);
+            var element = context.ExecutionPhases.Include(x => x.Client).FirstOrDefault(rec => rec.Id == model.Id);
             if (element != null)
             {
                 context.ExecutionPhases.Remove(element);

Factory/FactoryDatabaseImplement/Implements/MachineStorage.cs

@@ -0,0 +1,109 @@
+using FactoryContracts.BindingModels;
+using FactoryContracts.SearchModels;
+using FactoryContracts.StoragesContracts;
+using FactoryContracts.ViewModels;
+using FactoryDatabaseImplement.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace FactoryDatabaseImplement.Implements
+{
+    public class MachineStorage : IMachineStorage
+    {
+        public List<MachineViewModel> GetFullList()
+        {
+            using var context = new FactoryDatabase();
+            return context.Machines
+                    .Include(x => x.Client)
+                    .Include(x => x.PlanProductions)
+                    .ThenInclude(x => x.PlanProduction)
+                    .Select(x => x.GetViewModel)
+                    .ToList();
+        }
+
+        public List<MachineViewModel> GetFilteredList(MachineSearchModel model)
+        {
+            if (string.IsNullOrEmpty(model.MachineName))
+            {
+                return new();
+            }
+            using var context = new FactoryDatabase();
+            return context.Machines
+                    .Include(x => x.Client)
+                    .Include(x => x.PlanProductions)
+                    .ThenInclude(x => x.PlanProduction)
+                    .Where(x => x.MachineName.Contains(model.MachineName))
+                    .Select(x => x.GetViewModel)
+                    .ToList();
+        }
+
+        public MachineViewModel? GetElement(MachineSearchModel model)
+        {
+            if (string.IsNullOrEmpty(model.MachineName) && !model.Id.HasValue)
+            {
+                return null;
+            }
+            using var context = new FactoryDatabase();
+            return context.Machines
+                .Include(x => x.Client)
+                    .Include(x => x.PlanProductions)
+                    .ThenInclude(x => x.PlanProduction)
+                    .FirstOrDefault(x => (!string.IsNullOrEmpty(model.MachineName) && x.MachineName == model.MachineName) ||
+                                        (model.Id.HasValue && x.Id == model.Id))
+                    ?.GetViewModel;
+        }
+
+        public MachineViewModel? Insert(MachineBindingModel model)
+        {
+            using var context = new FactoryDatabase();
+            var newMachine = Machine.Create(context, model);
+            if (newMachine == null)
+            {
+                return null;
+            }
+            context.Machines.Add(newMachine);
+            context.SaveChanges();
+            return newMachine.GetViewModel;
+        }
+
+        public MachineViewModel? Update(MachineBindingModel model)
+        {
+            using var context = new FactoryDatabase();
+            using var transaction = context.Database.BeginTransaction();
+            try
+            {
+                var machine = context.Machines.FirstOrDefault(rec => rec.Id == model.Id);
+                if (machine == null)
+                {
+                    return null;
+                }
+                machine.Update(model);
+                context.SaveChanges();
+                machine.UpdatePlanProductions(context, model);
+                transaction.Commit();
+                return machine.GetViewModel;
+            }
+            catch
+            {
+                transaction.Rollback();
+                throw;
+            }
+        }
+
+        public MachineViewModel? Delete(MachineBindingModel model)
+        {
+            using var context = new FactoryDatabase();
+            var element = context.Machines
+                .Include(x => x.Client)
+                    .Include(x => x.PlanProductions)
+                    .ThenInclude(x => x.PlanProduction)
+                    .FirstOrDefault(rec => rec.Id == model.Id);
+            if (element != null)
+            {
+                context.Machines.Remove(element);
+                context.SaveChanges();
+                return element.GetViewModel;
+            }
+            return null;
+        }
+    }
+}

Factory/FactoryDatabaseImplement/Implements/PlanProductionStorage.cs

@@ -13,6 +13,7 @@ namespace FactoryDatabaseImplement.Implements
         {
             using var context = new FactoryDatabase();
             var element = context.PlanProductions
+                .Include(x => x.Client)
                 .Include(x => x.ExecutionPhase)
                 .Include(x => x.Workpieces)
                 .ThenInclude( x => x.Workpiece)
@@ -35,6 +36,7 @@ namespace FactoryDatabaseImplement.Implements
             using var context = new FactoryDatabase();
             if (model.Id.HasValue)
                 return context.PlanProductions
+                 .Include(x => x.Client)
                  .Include(x => x.ExecutionPhase)
                  .Include(x =>x.Workpieces)
                  .ThenInclude(x => x.Workpiece)
@@ -52,6 +54,7 @@ namespace FactoryDatabaseImplement.Implements
             {
                 return context.PlanProductions
                    .Where(x => x.Id == model.Id)
+                   .Include(x => x.Client)
                    .Include(x => x.ExecutionPhase)
                    .Include(x => x.Workpieces)
                    .ThenInclude(x => x.Workpiece)
@@ -67,6 +70,7 @@ namespace FactoryDatabaseImplement.Implements
         {
             using var context = new FactoryDatabase();
             return context.PlanProductions
+                    .Include (x => x.Client)
                     .Include(x => x.ExecutionPhase)
                     .Include(x => x.Workpieces)
                     .ThenInclude(x => x.Workpiece)
@@ -94,6 +98,7 @@ namespace FactoryDatabaseImplement.Implements
         {
             using var context = new FactoryDatabase();
             var order = context.PlanProductions
+                .Include(x => x.Client)
                 .Include(x => x.ExecutionPhase)
                 .Include(x => x.Workpieces)
                 .ThenInclude(x => x.Workpiece)

Factory/FactoryDatabaseImplement/Implements/ProductStorage.cs

@@ -0,0 +1,113 @@
+using FactoryContracts.BindingModels;
+using FactoryContracts.SearchModels;
+using FactoryContracts.StoragesContracts;
+using FactoryContracts.ViewModels;
+using FactoryDatabaseImplement.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace FactoryDatabaseImplement.Implements
+{
+    public class ProductStorage : IProductStorage
+    {
+        public List<ProductViewModel> GetFullList()
+        {
+            using var context = new FactoryDatabase();
+            return context.Products
+                    .Include(x => x.Client)
+                    .Include(x => x.Requirement)
+                    .Include(x => x.Machines)
+                    .ThenInclude(x => x.Machine)
+                    .Select(x => x.GetViewModel)
+                    .ToList();
+        }
+
+        public List<ProductViewModel> GetFilteredList(ProductSearchModel model)
+        {
+            if (string.IsNullOrEmpty(model.ProductName))
+            {
+                return new();
+            }
+            using var context = new FactoryDatabase();
+            return context.Products
+                    .Include(x => x.Client)
+                    .Include(x => x.Requirement)
+                    .Include(x => x.Machines)
+                    .ThenInclude(x => x.Machine)
+                    .Where(x => x.ProductName.Contains(model.ProductName))
+                    .Select(x => x.GetViewModel)
+                    .ToList();
+        }
+
+        public ProductViewModel? GetElement(ProductSearchModel model)
+        {
+            if (string.IsNullOrEmpty(model.ProductName) && !model.Id.HasValue)
+            {
+                return null;
+            }
+            using var context = new FactoryDatabase();
+            return context.Products
+                    .Include(x => x.Client)
+                    .Include(x => x.Requirement)
+                    .Include(x => x.Machines)
+                    .ThenInclude(x => x.Machine)
+                    .FirstOrDefault(x => (!string.IsNullOrEmpty(model.ProductName) && x.ProductName == model.ProductName) ||
+                                        (model.Id.HasValue && x.Id == model.Id))
+                    ?.GetViewModel;
+        }
+
+        public ProductViewModel? Insert(ProductBindingModel model)
+        {
+            using var context = new FactoryDatabase();
+            var newProduct = Product.Create(context, model);
+            if (newProduct == null)
+            {
+                return null;
+            }
+            context.Products.Add(newProduct);
+            context.SaveChanges();
+            return newProduct.GetViewModel;
+        }
+
+        public ProductViewModel? Update(ProductBindingModel model)
+        {
+            using var context = new FactoryDatabase();
+            using var transaction = context.Database.BeginTransaction();
+            try
+            {
+                var machine = context.Products.FirstOrDefault(rec => rec.Id == model.Id);
+                if (machine == null)
+                {
+                    return null;
+                }
+                machine.Update(model);
+                context.SaveChanges();
+                machine.UpdateMachines(context, model);
+                transaction.Commit();
+                return machine.GetViewModel;
+            }
+            catch
+            {
+                transaction.Rollback();
+                throw;
+            }
+        }
+
+        public ProductViewModel? Delete(ProductBindingModel model)
+        {
+            using var context = new FactoryDatabase();
+            var element = context.Products
+                    .Include(x => x.Client)
+                    .Include(x => x.Requirement)
+                    .Include(x => x.Machines)
+                    .ThenInclude(x => x.Machine)
+                    .FirstOrDefault(rec => rec.Id == model.Id);
+            if (element != null)
+            {
+                context.Products.Remove(element);
+                context.SaveChanges();
+                return element.GetViewModel;
+            }
+            return null;
+        }
+    }
+}

Factory/FactoryDatabaseImplement/Implements/RequirementStorage.cs

@@ -0,0 +1,88 @@
+using FactoryContracts.BindingModels;
+using FactoryContracts.SearchModels;
+using FactoryContracts.StoragesContracts;
+using FactoryContracts.ViewModels;
+using FactoryDatabaseImplement.Models;
+using Microsoft.EntityFrameworkCore;
+
+namespace FactoryDatabaseImplement.Implements
+{
+    public class RequirementStorage : IRequirementStorage
+    {
+        public List<RequirementViewModel> GetFullList()
+        {
+            using var context = new FactoryDatabase();
+            return context.Requirements
+                .Include(x => x.Client)
+                    .Select(x => x.GetViewModel)
+                    .ToList();
+        }
+
+        public List<RequirementViewModel> GetFilteredList(RequirementSearchModel model)
+        {
+            if (string.IsNullOrEmpty(model.RequirementName))
+            {
+                return new();
+            }
+            using var context = new FactoryDatabase();
+            return context.Requirements
+                .Include(x => x.Client)
+                    .Where(x => x.RequirementName.Contains(model.RequirementName))
+                    .Select(x => x.GetViewModel)
+                    .ToList();
+        }
+
+        public RequirementViewModel? GetElement(RequirementSearchModel model)
+        {
+            if (string.IsNullOrEmpty(model.RequirementName) && !model.Id.HasValue)
+            {
+                return null;
+            }
+            using var context = new FactoryDatabase();
+            return context.Requirements
+                .Include(x => x.Client)
+                    .FirstOrDefault(x => (!string.IsNullOrEmpty(model.RequirementName) && x.RequirementName == model.RequirementName) ||
+                                        (model.Id.HasValue && x.Id == model.Id))
+                    ?.GetViewModel;
+        }
+
+        public RequirementViewModel? Insert(RequirementBindingModel model)
+        {
+            var newRequirement = Requirement.Create(model);
+            if (newRequirement == null)
+            {
+                return null;
+            }
+            using var context = new FactoryDatabase();
+            context.Requirements.Add(newRequirement);
+            context.SaveChanges();
+            return newRequirement.GetViewModel;
+        }
+
+        public RequirementViewModel? Update(RequirementBindingModel model)
+        {
+            using var context = new FactoryDatabase();
+            var component = context.Requirements.FirstOrDefault(x => x.Id == model.Id);
+            if (component == null)
+            {
+                return null;
+            }
+            component.Update(model);
+            context.SaveChanges();
+            return component.GetViewModel;
+        }
+
+        public RequirementViewModel? Delete(RequirementBindingModel model)
+        {
+            using var context = new FactoryDatabase();
+            var element = context.Requirements.Include(x => x.Client).FirstOrDefault(rec => rec.Id == model.Id);
+            if (element != null)
+            {
+                context.Requirements.Remove(element);
+                context.SaveChanges();
+                return element.GetViewModel;
+            }
+            return null;
+        }
+    }
+}

Factory/FactoryDatabaseImplement/Implements/WorkpieceStorage.cs

@@ -13,6 +13,7 @@ namespace FactoryDatabaseImplement.Implements
 		{
 			using var context = new FactoryDatabase();
 			return context.Workpieces
+					.Include(x => x.Client)
 					.Include(x => x.Products)
 					.ThenInclude(x => x.Product)
 					.ToList()
@@ -28,6 +29,7 @@ namespace FactoryDatabaseImplement.Implements
 			}
 			using var context = new FactoryDatabase();
 			return context.Workpieces
+				.Include(x => x.Client)
 					.Include(x => x.Products)
 					.ThenInclude(x => x.Product)
 					.Where(x => x.WorkpieceName.Contains(model.WorkpieceName))
@@ -44,6 +46,7 @@ namespace FactoryDatabaseImplement.Implements
 			}
 			using var context = new FactoryDatabase();
 			return context.Workpieces
+				.Include(x => x.Client)
 				.Include(x => x.Products)
 				.ThenInclude(x => x.Product)
 				.FirstOrDefault(x => (!string.IsNullOrEmpty(model.WorkpieceName) && x.WorkpieceName == model.WorkpieceName) ||
@@ -91,7 +94,7 @@ namespace FactoryDatabaseImplement.Implements
 		public WorkpieceViewModel? Delete(WorkpieceBindingModel model)
 		{
 			using var context = new FactoryDatabase();
-			var element = context.Workpieces
+			var element = context.Workpieces.Include(x => x.Client)
 				.Include(x => x.Products)
 				.FirstOrDefault(rec => rec.Id == model.Id);
 			if (element != null)

Factory/FactoryDatabaseImplement/Models/Client.cs

@@ -1,5 +1,6 @@
 using FactoryContracts.BindingModels;
 using FactoryContracts.ViewModels;
+using FactoryDataModels.Enums;
 using FactoryDataModels.Models;
 using System.ComponentModel.DataAnnotations;
 using System.ComponentModel.DataAnnotations.Schema;
@@ -17,6 +18,7 @@ namespace FactoryDatabaseImplement.Models
         [Required]
         public string Password { get; private set; } = string.Empty;
 
+        public ClientRole Role { get; private set; } = ClientRole.Неизвестен;
 
         [ForeignKey("ClientId")]
         public virtual List<ExecutionPhase> ExecutionPhases{ get; set; } = new();
@@ -39,6 +41,7 @@ namespace FactoryDatabaseImplement.Models
                 Login = model.Login,
                 Email= model.Email,
                 Password = model.Password,
+                Role = model.Role,
             };
         }
 
@@ -50,6 +53,7 @@ namespace FactoryDatabaseImplement.Models
                 Login = model.Login,
                 Email = model.Email,
                 Password = model.Password,
+                Role = model.Role,
             };
         }
 
@@ -70,6 +74,7 @@ namespace FactoryDatabaseImplement.Models
             Login = Login,
             Email = Email,
             Password = Password,
+            Role = Role,
         };
     }
 }

Factory/FactoryDatabaseImplement/Models/ExecutionPhase.cs

@@ -69,6 +69,7 @@ namespace FactoryDatabaseImplement.Models
             ExecutionPhaseName = ExecutionPhaseName,
             ImplementerFIO = ImplementerFIO,
             ClientId = ClientId,
+            ClientLogin = Client.Login,
             Status = Status,
         };
     }

Factory/FactoryDatabaseImplement/Models/Machine.cs

@@ -0,0 +1,116 @@
+using FactoryContracts.BindingModels;
+using FactoryContracts.ViewModels;
+using FactoryDataModels.Models;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace FactoryDatabaseImplement.Models
+{
+    public class Machine : IMachineModel
+    {
+        public int Id { get; private set; }
+
+        [Required]
+        public int ClientId { get; private set; }
+
+        public virtual Client Client { get; private set; } = new();
+
+        [Required]
+        public string MachineName { get; private set; } = string.Empty;
+
+        [Required]
+        public DateTime ExploitationStartDate { get; private set; } = DateTime.Now;
+
+        [Required]
+        public int Lifetime { get; private set; }
+
+        public Dictionary<int, (IPlanProductionModel, int)> _machinePlanProductions { get; private set; } = new();
+
+        [NotMapped]
+        public Dictionary<int, (IPlanProductionModel, int)> MachinePlanProductions
+        {
+            get
+            {
+                if (_machinePlanProductions == null)
+                {
+                    _machinePlanProductions = PlanProductions
+                            .ToDictionary(recPC => recPC.PlanProductionId, recPC => (recPC.PlanProduction as IPlanProductionModel, recPC.Count));
+                }
+                return _machinePlanProductions;
+            }
+        }
+        [ForeignKey("MachineId")]
+        public virtual List<MachinePlanProduction> PlanProductions { get; private set; } = new();
+
+        [ForeignKey("MachineId")]
+        public virtual List<ProductMachine> Products { get; private set; } = new();
+
+        public static Machine Create(FactoryDatabase context, MachineBindingModel model)
+        {
+            if (model == null)
+            {
+                return null;
+            }
+            return new Machine()
+            {
+                Id = model.Id,
+                ClientId = model.ClientId,
+                MachineName = model.MachineName,
+                ExploitationStartDate = model.ExploitationStartDate,
+                Lifetime = model.Lifetime,
+                PlanProductions = model.MachinePlanProductions.Select(x => new MachinePlanProduction
+                {
+                    PlanProduction = context.PlanProductions.First(y => y.Id == x.Key),
+                    Count = x.Value.Item2
+                }).ToList()
+            };
+        }
+
+        public void Update(MachineBindingModel model)
+        {
+            if (model == null)
+            {
+                return;
+            }
+            MachineName = model.MachineName;
+        }
+
+        public MachineViewModel GetViewModel => new()
+        {
+            Id = Id,
+            ClientId = ClientId,
+            MachineName = MachineName,
+            ExploitationStartDate = ExploitationStartDate,
+            Lifetime = Lifetime,
+            ClientLogin = Client.Login,
+            MachinePlanProductions = MachinePlanProductions,
+        };
+        public void UpdatePlanProductions(FactoryDatabase context, MachineBindingModel model)
+        {
+            var machinePlanProductions = context.MachinePlanProductions.Where(rec => rec.MachineId == model.Id).ToList();
+            if (machinePlanProductions != null && machinePlanProductions.Count > 0)
+            {
+                context.MachinePlanProductions.RemoveRange(machinePlanProductions.Where(rec => !model.MachinePlanProductions.ContainsKey(rec.PlanProductionId)));
+                context.SaveChanges();
+                foreach (var updatePlanProduction in machinePlanProductions)
+                {
+                    updatePlanProduction.Count = model.MachinePlanProductions[updatePlanProduction.PlanProductionId].Item2;
+                    model.MachinePlanProductions.Remove(updatePlanProduction.PlanProductionId);
+                }
+                context.SaveChanges();
+            }
+            var machine = context.Machines.First(x => x.Id == Id);
+            foreach (var pc in model.MachinePlanProductions)
+            {
+                context.MachinePlanProductions.Add(new MachinePlanProduction
+                {
+                    Machine = machine,
+                    PlanProduction = context.PlanProductions.First(x => x.Id == pc.Key),
+                    Count = pc.Value.Item2
+                });
+                context.SaveChanges();
+            }
+            _machinePlanProductions = null;
+        }
+    }
+}

Factory/FactoryDatabaseImplement/Models/MachinePlanProduction.cs

@@ -6,13 +6,17 @@ namespace FactoryDatabaseImplement.Models
     {
         public int Id { get; set; }
 
-        //[Required]
-        //public int MachineId { get; set; }
+        [Required]
+        public int MachineId { get; set; }
 
         [Required]
         public int PlanProductionId { get; set; }
+
+        [Required]
+        public int Count { get; set; }
+
         public virtual PlanProduction PlanProduction { get; set; } = new();
 
-        //public virtual Machine Machine{ get; set; } = new();
+        public virtual Machine Machine { get; set; } = new();
     }
 }

Factory/FactoryDatabaseImplement/Models/PlanProduction.cs

@@ -22,7 +22,7 @@ namespace FactoryDatabaseImplement.Models
         [Required]
         public int Count { get; private set; }
         [Required]
-        public DateTime Term { get; private set; }
+        public DateTime Deadline { get; private set; }
 
         private Dictionary<int, (IWorkpieceModel, int)>? _planProductionWorkpieces = null;
 
@@ -57,7 +57,7 @@ namespace FactoryDatabaseImplement.Models
                 Count = model.Count,
                 ExecutionPhaseId = model.ExecutionPhaseId,
                 ProductionName = model.ProductionName,
-                Term = model.Term,
+                Deadline = model.Deadline,
                 Workpieces = model.PlanProductionWorkpieces.Select(x => new PlanProductionWorkpiece
                 {
                     Workpiece = context.Workpieces.First(y => y.Id == x.Key),
@@ -75,7 +75,7 @@ namespace FactoryDatabaseImplement.Models
             Count = model.Count;
             ExecutionPhaseId = model.ExecutionPhaseId;
             ProductionName = model.ProductionName;
-            Term = model.Term;
+            Deadline = model.Deadline;
 
         }
 
@@ -83,9 +83,11 @@ namespace FactoryDatabaseImplement.Models
         {
             Id = Id,
             ClientId = ClientId,
+            ClientLogin = Client.Login,
             ExecutionPhaseId = ExecutionPhaseId,
+            ExecutionPhaseName = ExecutionPhase.ExecutionPhaseName,
             ProductionName = ProductionName,
-            Term = Term,
+            Deadline = Deadline,
             Count = Count,
             PlanProductionWorkpieces = PlanProductionWorkpieces
         };

Factory/FactoryDatabaseImplement/Models/Product.cs

@@ -0,0 +1,120 @@
+using FactoryContracts.BindingModels;
+using FactoryContracts.ViewModels;
+using FactoryDataModels.Models;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace FactoryDatabaseImplement.Models
+{
+    public class Product : IProductModel
+    {
+        public int Id { get; private set; }
+
+        [Required]
+        public int ClientId { get; private set; }
+
+        public virtual Client Client { get; private set; } = new();
+
+        [Required]
+        public int RequirementId { get; private set; }
+
+        public virtual Requirement Requirement { get; private set; } = new();
+
+        [Required]
+        public string ProductName { get; private set; } = string.Empty;
+
+        public double Price { get; private set; }
+
+        public Dictionary<int, (IMachineModel, int)> _productMachines { get; private set; } = new();
+
+        [NotMapped]
+        public Dictionary<int, (IMachineModel, int)> ProductMachines
+        {
+            get
+            {
+                if (_productMachines == null)
+                {
+                    _productMachines = Machines
+                        .ToDictionary(recPC => recPC.MachineId, recPC => (recPC.Machine as IMachineModel, recPC.Count));
+                }
+                return _productMachines;
+            }
+        }
+
+        [ForeignKey("ProductId")]
+        public virtual List<ProductMachine> Machines { get; private set; } = new();
+
+        [ForeignKey("ProductId")]
+        public virtual List<WorkpieceProduct> Workpieces { get; private set; } = new();
+
+        public static Product Create(FactoryDatabase context, ProductBindingModel model)
+        {
+            if (model == null)
+            {
+                return null;
+            }
+            return new Product()
+            {
+                Id = model.Id,
+                ClientId = model.ClientId,
+                RequirementId = model.RequirementId,
+                ProductName = model.ProductName,
+                Price = model.Price,
+                Machines = model.ProductMachines.Select(x => new ProductMachine
+                {
+                    Machine = context.Machines.First(y => y.Id == x.Key),
+                    Count = x.Value.Item2
+                }).ToList()
+            };
+        }
+
+        public void Update(ProductBindingModel model)
+        {
+            if (model == null)
+            {
+                return;
+            }
+            ProductName = model.ProductName;
+            Price = model.Price;
+        }
+
+        public ProductViewModel GetViewModel => new()
+        {
+            Id = Id,
+            ClientId = ClientId,
+            RequirementId = RequirementId,
+            ProductName = ProductName,
+            ClientLogin = Client.Login,
+            RequirementName = Requirement.RequirementName,
+            Price = Price,
+            ProductMachines = ProductMachines,
+        };
+        public void UpdateMachines(FactoryDatabase context, ProductBindingModel model)
+        {
+            var productMachines = context.ProductMachines.Where(rec => rec.ProductId == model.Id).ToList();
+            if (productMachines != null && productMachines.Count > 0)
+            {
+                context.ProductMachines.RemoveRange(productMachines.Where(rec => !model.ProductMachines.ContainsKey(rec.MachineId)));
+                context.SaveChanges();
+                foreach (var updateMachine in productMachines)
+                {
+                    updateMachine.Count = model.ProductMachines[updateMachine.MachineId].Item2;
+                    model.ProductMachines.Remove(updateMachine.MachineId);
+                }
+                context.SaveChanges();
+            }
+            var machine = context.Machines.First(x => x.Id == Id);
+            foreach (var pc in model.ProductMachines)
+            {
+                context.ProductMachines.Add(new ProductMachine
+                {
+                    Product = context.Products.First(x => x.Id == pc.Key),
+                    Machine = machine,
+                    Count = pc.Value.Item2
+                });
+                context.SaveChanges();
+            }
+            _productMachines = null;
+        }
+    }
+}

Factory/FactoryDatabaseImplement/Models/ProductMachine.cs

@@ -0,0 +1,22 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace FactoryDatabaseImplement.Models
+{
+    public class ProductMachine
+    {
+        public int Id { get; set; }
+
+        [Required]
+        public int ProductId { get; set; }
+
+        public virtual Product Product { get; set; } = new();
+
+        [Required]
+        public int MachineId { get; set; }
+
+        public virtual Machine Machine { get; set; } = new();
+
+        [Required]
+        public int Count { get; set; }
+    }
+}

Factory/FactoryDatabaseImplement/Models/Requirement.cs

@@ -0,0 +1,65 @@
+using FactoryContracts.BindingModels;
+using FactoryContracts.ViewModels;
+using FactoryDataModels.Models;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace FactoryDatabaseImplement.Models
+{
+    public class Requirement : IRequirementModel
+    {
+        public int Id { get; private set; }
+
+        [Required]
+        public int ClientId { get; private set; }
+
+        public virtual Client Client { get; private set; } = new();
+
+        [Required]
+        public string RequirementName { get; private set; } = string.Empty;
+
+        [Required]
+        public string Description { get; private set; } = string.Empty;
+
+        [Required]
+        public int Lifetime { get; private set; }
+
+        [ForeignKey("RequirementId")]
+        public virtual Product Product { get; private set; } = new();
+
+        public static Requirement Create(RequirementBindingModel model)
+        {
+            if (model == null)
+            {
+                return null;
+            }
+            return new Requirement()
+            {
+                Id = model.Id,
+                RequirementName = model.RequirementName,
+                Description = model.Description,
+                Lifetime = model.Lifetime,
+                ClientId = model.ClientId,
+            };
+        }
+
+        public void Update(RequirementBindingModel model)
+        {
+            if (model == null)
+            {
+                return;
+            }
+            RequirementName = model.RequirementName;
+            Description = model.Description;
+        }
+
+        public RequirementViewModel GetViewModel => new()
+        {
+            Id = Id,
+            ClientId = ClientId,
+            RequirementName = RequirementName,
+            Lifetime = Lifetime,
+            ClientLogin = Client.Login,
+        };
+    }
+}

Factory/FactoryDatabaseImplement/Models/Workpiece.cs

@@ -24,7 +24,7 @@ namespace FactoryDatabaseImplement.Models
         private Dictionary<int, (IProductModel, int)>? _workpieceProducts = null;
 
         [NotMapped]
-        public Dictionary<int, (IWorkpieceModel, int)> WorkpieceProducts
+        public Dictionary<int, (IProductModel, int)> WorkpieceProducts
         {
             get
             {
@@ -51,7 +51,7 @@ namespace FactoryDatabaseImplement.Models
                 Cost = model.Cost,
                 Material = model.Material,
                 ClientId = model.ClientId,
-                Products = model.WorkpiecesProducts.Select(x => new WorkpieceProduct
+                Products = model.WorkpieceProducts.Select(x => new WorkpieceProduct
                 {
                     Product = context.Products.First(y => y.Id == x.Key),
                     Count = x.Value.Item2
@@ -73,7 +73,8 @@ namespace FactoryDatabaseImplement.Models
             Cost = Cost,
             Material = Material,
             ClientId = ClientId,
-            WorkpiecesProducts = WorkpieceProducts
+            ClientLogin = Client.Login,
+            WorkpieceProducts = WorkpieceProducts
         };
 
         public void UpdateProducts(FactoryDatabase context, WorkpieceBindingModel model)
@@ -81,17 +82,17 @@ namespace FactoryDatabaseImplement.Models
             var workpieceProducts = context.WorkpieceProducts.Where(rec => rec.WorkpieceId == model.Id).ToList();
             if (workpieceProducts != null && workpieceProducts.Count > 0)
             {   
-                context.WorkpieceProducts.RemoveRange(workpieceProducts.Where(rec => !model.WorkpiecesProducts.ContainsKey(rec.ProductId)));
+                context.WorkpieceProducts.RemoveRange(workpieceProducts.Where(rec => !model.WorkpieceProducts.ContainsKey(rec.ProductId)));
                 context.SaveChanges();
                 foreach (var updateProduct in workpieceProducts)
                 {
-                    updateProduct.Count = model.WorkComponents[updateProduct.ProductId].Item2;
-                    model.WorkpiecesProducts.Remove(updateProduct.ProductId);
+                    updateProduct.Count = model.WorkpieceProducts[updateProduct.ProductId].Item2;
+                    model.WorkpieceProducts.Remove(updateProduct.ProductId);
                 }
                 context.SaveChanges();
             }
             var workpiece = context.Workpieces.First(x => x.Id == Id);
-            foreach (var pc in model.WorkpiecesProducts)
+            foreach (var pc in model.WorkpieceProducts)
             {
                 context.WorkpieceProducts.Add(new WorkpieceProduct
                 {