Слил 5 хард и 6 хард

TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/ComplitedWorkBusinessLogicContract.cs

@@ -2,14 +2,17 @@
 using TwoFromTheCasketContracts.BusinessLogicsContracts;
 using TwoFromTheCasketContracts.DataModels;
 using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketContracts.Infastructure.SalaryConfiguration;
 using TwoFromTheCasketContracts.StorageContracts;
 using static System.Runtime.InteropServices.JavaScript.JSType;
 
 namespace TwoFromTheCasketBusinessLogic.Implementation;
 
-internal class ComplitedWorkBusinessLogicContract(IComplitedWorkStorageContract _complitedWorkStorageContract, ILogger _logger) : IComplitedWorkBusinessLogicContract
+internal class ComplitedWorkBusinessLogicContract(IComplitedWorkStorageContract _complitedWorkStorageContract, IWarehouseStorageContract _complitedWorkDataModel, ILogger _logger, IWorkerStorageContract _workerStorageContract) : IComplitedWorkBusinessLogicContract
 {
     private IComplitedWorkStorageContract complitedWorkStorageContract = _complitedWorkStorageContract;
+    private IWarehouseStorageContract warehouseStorageContract = _complitedWorkDataModel;
+    private IWorkerStorageContract workerStorageContract = _workerStorageContract;
     private ILogger logger = _logger;
 
     public List<ComplitedWorkDataModel> GetComplitedWorksByPeriod(DateTime fromDate, DateTime toDate)
@@ -88,8 +91,78 @@ internal class ComplitedWorkBusinessLogicContract(IComplitedWorkStorageContract
         return result;
     }
 
+    public int CalculateProfitByPeriod(DateTime fromDate, DateTime toDate)
+    {
+        if (fromDate > toDate)
+            throw new ArgumentException("fromDate must be earlier than toDate");
 
+        var completedWorks = _complitedWorkStorageContract.GetList(fromDate, toDate);
+        var profit = 0;
+        var semaphore = new SemaphoreSlim(4);
+        var locker = new object();
 
+        var tasks = new List<Task>();
+        var groupedByDay = completedWorks.GroupBy(w => w.Date.Date).ToList();
+
+        foreach (var group in groupedByDay)
+        {
+            var dateCopy = group.Key;
+            var dailyWorks = group.ToList();
+
+            tasks.Add(Task.Run(async () =>
+            {
+                await semaphore.WaitAsync();
+                try
+                {
+                    int localProfit = 0;
+
+                    foreach (var work in dailyWorks)
+                    {
+                        foreach (var wcw in work.Workers)
+                        {
+                            var worker = workerStorageContract.GetElementById(wcw.WorkerId);
+                            var config = worker.ConfigurationModel;
+
+                            switch (config.Type)
+                            {
+                                case nameof(PieceworkSalaryConfiguration):
+                                    var pieceCfg = config as PieceworkSalaryConfiguration;
+                                    if (pieceCfg != null)
+                                    {
+                                        localProfit += (int)(pieceCfg.UnitRate * wcw.NumberOfWorkingHours + pieceCfg.BonusPerUnit);
+                                    }
+                                    break;
+
+                                case nameof(OvertimeSalaryConfiguration):
+                                    var overCfg = config as OvertimeSalaryConfiguration;
+                                    if (overCfg != null)
+                                    {
+                                        localProfit += (int)(config.Rate * wcw.NumberOfWorkingHours * overCfg.OvertimeMultiplier);
+                                    }
+                                    break;
+
+                                default:
+                                    localProfit += (int)(config.Rate * wcw.NumberOfWorkingHours);
+                                    break;
+                            }
+                        }
+                    }
+
+                    lock (locker)
+                    {
+                        profit += localProfit;
+                    }
+                }
+                finally
+                {
+                    semaphore.Release();
+                }
+            }));
+        }
+
+        Task.WaitAll(tasks.ToArray());
+        return profit;
+    }
 
     public List<ComplitedWorkDataModel> GetComplitedWorksByWorkTypeByPeriod(string workId, DateTime fromDate, DateTime toDate)
     {
@@ -189,6 +262,12 @@ internal class ComplitedWorkBusinessLogicContract(IComplitedWorkStorageContract
             throw new ValidationException("Completed work must have at least one assigned worker.");
         }
 
+        if (!warehouseStorageContract.CheckWorks(complitedWorkDataModel))
+        {
+            logger.LogError("Not enough works for ComplitedWorks.");
+            throw new ValidationException("Not enough works for ComplitedWorks.");
+        }
+
         logger.LogInformation("Completed work {ComplitedWorkId} has been validated successfully.", complitedWorkDataModel.Id);
         complitedWorkStorageContract.AddElement(complitedWorkDataModel);
     }

TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/RoomBusinessLogicContract.cs

@@ -67,6 +67,34 @@ internal class RoomBusinessLogicContract(IRoomStorageContract _roomStorageContra
         return rooms;
     }
 
+    public List<RoomHistoryDataModel> GetRoomHistory(string roomId)
+    {
+        logger.LogInformation("Retrieving history for room: {RoomId}", roomId);
+
+        if (string.IsNullOrWhiteSpace(roomId))
+        {
+            logger.LogError("Room ID is null or empty.");
+            throw new ArgumentNullException(nameof(roomId));
+        }
+
+        if (!Guid.TryParse(roomId, out _))
+        {
+            logger.LogError("Invalid room ID format: {RoomId}", roomId);
+            throw new ValidationException("Invalid room ID.");
+        }
+
+        var history = roomStorageContract.GetHistoryRoomId(roomId);
+
+        if (history == null)
+        {
+            logger.LogError("No history found for room ID: {RoomId}", roomId);
+            throw new NullListException();
+        }
+
+        logger.LogInformation("Retrieved {Count} history records for room ID: {RoomId}", history.Count, roomId);
+        return history;
+    }
+
     public RoomDataModel GetRoomByData(string roomId)
     {
         logger.LogInformation("Retrieving room by ID: {RoomId}", roomId);

TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/RoomHistoryBusinessLogicContract.cs

@@ -1,101 +0,0 @@
-using Microsoft.Extensions.Logging;
-using TwoFromTheCasketContracts.BusinessLogicsContracts;
-using TwoFromTheCasketContracts.DataModels;
-using TwoFromTheCasketContracts.Exceptions;
-using TwoFromTheCasketContracts.StorageContracts;
-
-namespace TwoFromTheCasketBusinessLogic.Implementation;
-
-internal class RoomHistoryBusinessLogicContract(IRoomHistoryStorageContract _roomHistoryStorageContract, ILogger _logger) : IRoomHistoryBusinessLogicContract
-{
-    private IRoomHistoryStorageContract roomHistoryStorageContract = _roomHistoryStorageContract;
-    private ILogger logger = _logger;
-    public List<RoomHistoryDataModel> GetRoomHistory(string roomId)
-    {
-        logger.LogInformation("Retrieving history for room: {RoomId}", roomId);
-
-        if (string.IsNullOrWhiteSpace(roomId))
-        {
-            logger.LogError("Room ID is null or empty.");
-            throw new ArgumentNullException(nameof(roomId));
-        }
-
-        if (!Guid.TryParse(roomId, out _))
-        {
-            logger.LogError("Invalid room ID format: {RoomId}", roomId);
-            throw new ValidationException("Invalid room ID.");
-        }
-
-        var history = roomHistoryStorageContract.GetList(roomId);
-
-        if (history == null)
-        {
-            logger.LogError("No history found for room ID: {RoomId}", roomId);
-            throw new NullListException();
-        }
-
-        logger.LogInformation("Retrieved {Count} history records for room ID: {RoomId}", history.Count, roomId);
-        return history;
-    }
-
-    public RoomHistoryDataModel GetLatestRoomHistory(string roomId)
-    {
-        logger.LogInformation("Retrieving latest history for room: {RoomId}", roomId);
-
-        if (string.IsNullOrWhiteSpace(roomId))
-        {
-            logger.LogError("Room ID is null or empty.");
-            throw new ArgumentNullException(nameof(roomId));
-        }
-
-        if (!Guid.TryParse(roomId, out _))
-        {
-            logger.LogError("Invalid room ID format: {RoomId}", roomId);
-            throw new ValidationException("Invalid room ID.");
-        }
-
-        var historyRecords = roomHistoryStorageContract.GetList(roomId);
-
-        if (historyRecords == null || historyRecords.Count == 0)
-        {
-            logger.LogError("No history records found for room ID: {RoomId}", roomId);
-            throw new NullListException();
-        }
-
-        var latestHistory = historyRecords.MaxBy(h => h.DateChange);
-        if (latestHistory == null)
-        {
-            logger.LogError("Failed to determine latest history record for room ID: {RoomId}", roomId);
-            throw new NullListException();
-        }
-
-        logger.LogInformation("Retrieved latest history record for room ID: {RoomId}", roomId);
-        return latestHistory;
-    }
-
-    public void AddRoomHistory(RoomHistoryDataModel roomHistoryDataModel)
-    {
-        logger.LogInformation("Adding room history.");
-
-        if (roomHistoryDataModel == null)
-        {
-            logger.LogError("Attempted to insert a null room history.");
-            throw new ArgumentNullException(nameof(roomHistoryDataModel));
-        }
-
-        if (!Guid.TryParse(roomHistoryDataModel.RoomId, out _))
-        {
-            logger.LogError("Invalid room ID: {RoomId}", roomHistoryDataModel.RoomId);
-            throw new ValidationException("Invalid room ID.");
-        }
-
-        if (roomHistoryDataModel.DateChange == default)
-        {
-            logger.LogError("Invalid change date.");
-            throw new ValidationException("Invalid change date.");
-        }
-
-        roomHistoryStorageContract.AddElement(roomHistoryDataModel);
-        logger.LogInformation("Room history added successfully for room: {RoomId}", roomHistoryDataModel.RoomId);
-    }
-}

TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/SalaryBusinessLogicContract.cs

@@ -30,7 +30,7 @@ internal class SalaryBusinessLogicContract(ISalaryStorageContract _salaryStorage
         if (fromDate >= toDate)
             throw new IncorrectDatesException(fromDate,toDate);
 
-        _logger.LogInformation("Fetching salaries for worker {WorkerId} from {FromDate} to {ToDate}", workerId, fromDate, toDate);
+        logger.LogInformation("Fetching salaries for worker {WorkerId} from {FromDate} to {ToDate}", workerId, fromDate, toDate);
 
         var salaries = _salaryStorageContract.GetList(fromDate, toDate, workerId) ?? throw new NullListException();
 
@@ -42,7 +42,7 @@ internal class SalaryBusinessLogicContract(ISalaryStorageContract _salaryStorage
         if (fromDate >= toDate)
             throw new IncorrectDatesException(fromDate,toDate);
 
-        _logger.LogInformation("Fetching salaries from {FromDate} to {ToDate}", fromDate, toDate);
+        logger.LogInformation("Fetching salaries from {FromDate} to {ToDate}", fromDate, toDate);
 
         var salaries = _salaryStorageContract.GetList(fromDate, toDate, null) ?? throw new NullListException();
 

TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/SupplyBusinessLogicContract.cs

@@ -0,0 +1,201 @@
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContracts.BusinessLogicsContracts;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketContracts.StorageContracts;
+
+namespace TwoFromTheCasketBusinessLogic.Implementation;
+
+internal class SupplyBusinessLogicContract(ISupplyStorageContract _supplyStorageContract, ILogger _logger) : ISupplyBuisnessLogicContract
+{
+    private ISupplyStorageContract supplyStorageContract = _supplyStorageContract;
+    private ILogger logger = _logger;
+
+    public List<SupplyDataModel> GetSuppliesByPeriod(DateTime fromDate, DateTime toDate)
+    {
+        logger.LogInformation("Retrieving supplies from {FromDate} to {ToDate}", fromDate, toDate);
+
+        if (fromDate >= toDate)
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+
+        var supplies = supplyStorageContract.GetList(fromDate, toDate);
+
+        if (supplies == null)
+        {
+            throw new NullListException();
+        }
+
+        if (supplies.Count == 0)
+        {
+            throw new ElementNotFoundException($"No supplies found in the period from {fromDate} to {toDate}.");
+        }
+
+        return supplies;
+    }
+
+    public List<SupplyDataModel> GetSuppliesByWarehouseId(string warehouseId)
+    {
+        logger.LogInformation("Retrieving supplies for warehouse: {WarehouseId}", warehouseId);
+
+        if (string.IsNullOrWhiteSpace(warehouseId))
+        {
+            throw new ArgumentNullException(nameof(warehouseId));
+        }
+
+        if (!Guid.TryParse(warehouseId, out _))
+        {
+            throw new ValidationException("Invalid warehouse ID format.");
+        }
+
+        var supplies = supplyStorageContract.GetList(DateTime.MinValue, DateTime.MaxValue, warehouseId);
+
+        if (supplies == null)
+        {
+            throw new NullListException();
+        }
+
+        if (supplies.Count == 0)
+        {
+            throw new ElementNotFoundException($"No supplies found for warehouse ID: {warehouseId}.");
+        }
+
+        return supplies;
+    }
+    public SupplyDataModel GetSupplyByData(string data)
+    {
+        logger.LogInformation("Retrieving supply by data: {Data}", data);
+
+        if (string.IsNullOrWhiteSpace(data))
+        {
+            throw new ArgumentNullException(nameof(data));
+        }
+
+        if (!Guid.TryParse(data, out _))
+        {
+            throw new ValidationException("The value in the field Id is not a unique identifier.");
+        }
+
+        List<SupplyDataModel>? supplies;
+
+        try
+        {
+            supplies = supplyStorageContract.GetList(DateTime.MinValue, DateTime.MaxValue);
+        }
+        catch (Exception ex)
+        {
+            throw new StorageException(ex);
+        }
+
+        if (!supplies.Any())
+        {
+            throw new ElementNotFoundException($"No supply found for data: {data}");
+        }
+
+        if (supplies == null)
+        {
+            throw new NullListException();
+        }
+
+        var supply = supplies.FirstOrDefault(s => s.Id == data || s.WarehouseId == data);
+
+        if (supply == null)
+        {
+            throw new ElementNotFoundException($"No supply found for data: {data}");
+        }
+
+        return supply;
+    }
+
+    public int CountSupplyByPeriod(string workId, DateTime fromDate, DateTime toDate)
+    {
+        if (fromDate > toDate)
+        {
+            throw new IncorrectDatesException(fromDate, toDate);
+        }
+
+        var supplies = _supplyStorageContract.GetList(fromDate, toDate);
+        int totalQuantity = 0;
+
+        Parallel.ForEach(supplies, () => 0, (supply, state, localCount) =>
+        {
+            localCount += supply.Works
+                .Where(x => x.WorkId == workId)
+                .Sum(x => (int)x.Quantity);
+            return localCount;
+        },
+        localTotal =>
+        {
+            Interlocked.Add(ref totalQuantity, localTotal);
+        });
+
+        return totalQuantity;
+    }
+
+
+    public void InsertSupply(SupplyDataModel supplyDataModel)
+    {
+        logger.LogInformation("Inserting new supply: {@Supply}", supplyDataModel);
+
+        if (supplyDataModel == null)
+        {
+            throw new ArgumentNullException(nameof(supplyDataModel));
+        }
+
+        supplyDataModel.Validate();
+
+        var existingSupply = supplyStorageContract.GetElementById(supplyDataModel.Id);
+        if (existingSupply != null)
+        {
+            throw new ElementExistsException($"Supply", supplyDataModel.Id);
+        }
+
+        try
+        {
+            supplyStorageContract.AddElement(supplyDataModel);
+            logger.LogInformation("Supply {SupplyId} inserted successfully", supplyDataModel.Id);
+        }
+        catch (Exception ex)
+        {
+            throw new StorageException(ex);
+        }
+    }
+
+    public void DeleteSupply(string id)
+    {
+        logger.LogInformation("Deleting supply with ID: {SupplyId}", id);
+
+        if (string.IsNullOrWhiteSpace(id))
+        {
+            throw new ArgumentNullException(nameof(id));
+        }
+
+        if (!Guid.TryParse(id, out _))
+        {
+            throw new ValidationException("Invalid supply ID format.");
+        }
+
+        var existingSupply = supplyStorageContract.GetElementById(id);
+        if (existingSupply == null)
+        {
+            throw new ElementNotFoundException($"Supply with ID {id} not found.");
+        }
+
+        try
+        {
+            supplyStorageContract.DelElement(id);
+            logger.LogInformation("Supply {SupplyId} deleted successfully", id);
+        }
+        catch (Exception ex)
+        {
+            throw new StorageException(ex);
+        }
+    }
+
+}

TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/WarehouseBusinessLogicContract.cs

@@ -0,0 +1,196 @@
+using Microsoft.Extensions.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContracts.BusinessLogicsContracts;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketContracts.Extensions;
+using TwoFromTheCasketContracts.StorageContracts;
+
+namespace TwoFromTheCasketBusinessLogic.Implementation;
+
+internal class WarehouseBusinessLogicContract(IWarehouseStorageContract _warehouseStorageContract, ILogger _logger, IComplitedWorkStorageContract complitedWorkStorageContract, ISupplyStorageContract _supplyStorageContract) : IWarehouseBuisnessLogicContract
+{
+    private IWarehouseStorageContract warehouseStorageContract = _warehouseStorageContract;
+    private ISupplyStorageContract supplyStorageContract = _supplyStorageContract;
+    private IComplitedWorkStorageContract? _complitedWorkStorageContract = complitedWorkStorageContract;
+    private ILogger logger = _logger;
+
+    public WarehouseDataModel GetWarehouseByData(string warehouseId)
+    {
+        logger.LogInformation("Retrieving warehouse data for ID: {WarehouseId}", warehouseId);
+
+        if (string.IsNullOrWhiteSpace(warehouseId))
+            throw new ArgumentNullException(nameof(warehouseId));
+
+        if (!warehouseId.IsGuid())
+            throw new ValidationException($"Invalid warehouse ID format: {warehouseId}");
+
+        var warehouse = warehouseStorageContract.GetElementById(warehouseId);
+
+        if (warehouse == null)
+            throw new ElementNotFoundException($"Warehouse with ID {warehouseId} not found.");
+
+        logger.LogInformation("Warehouse found: {WarehouseName}, Location: {WarehouseLocation}",
+            warehouse.Name, warehouse.Location);
+
+        return warehouse;
+    }
+
+    public List<WarehouseDataModel> GetWarehousesByLocation(string warehouseLocation)
+    {
+        logger.LogInformation("Retrieving warehouses at location: {WarehouseLocation}", warehouseLocation);
+
+        if (string.IsNullOrWhiteSpace(warehouseLocation))
+            throw new ArgumentNullException(nameof(warehouseLocation));
+
+        var warehouses = warehouseStorageContract.GetListByLocation(warehouseLocation);
+
+        if (warehouses == null)
+            throw new NullListException();
+
+        if (warehouses.Count == 0)
+            throw new ElementNotFoundException($"No warehouses found at location {warehouseLocation}.");
+
+        logger.LogInformation("Found {Count} warehouses at location {WarehouseLocation}", warehouses.Count, warehouseLocation);
+
+        return warehouses;
+    }
+
+
+    public List<WarehouseDataModel> GetWarehousesByName(string warehouseName)
+    {
+        logger.LogInformation("Retrieving warehouses with name: {WarehouseName}", warehouseName);
+
+        if (string.IsNullOrWhiteSpace(warehouseName))
+            throw new ArgumentNullException(nameof(warehouseName));
+
+        var warehouses = warehouseStorageContract.GetListByName(warehouseName);
+
+        if (warehouses == null)
+            throw new NullListException();
+
+        if (warehouses.Count == 0)
+            throw new ElementNotFoundException($"No warehouses found with name {warehouseName}.");
+
+        logger.LogInformation("Found {Count} warehouses with name {WarehouseName}", warehouses.Count, warehouseName);
+
+        return warehouses;
+    }
+
+    public int CountSupplyRemainderByPeriod(string workId, DateTime fromDate, DateTime toDate)
+    {
+        if (string.IsNullOrWhiteSpace(workId))
+            throw new ArgumentNullException(nameof(workId));
+        if (fromDate > toDate)
+            throw new ArgumentException("fromDate must be earlier than toDate");
+
+        var incomingTask = Task.Run(() =>
+        {
+            var supplies = supplyStorageContract.GetList(fromDate, toDate);
+            return supplies
+                .SelectMany(s => s.Works)
+                .Where(ws => ws.WorkId == workId)
+                .Sum(ws => (int)ws.Quantity);
+        });
+
+        var outcomingTask = Task.Run(() =>
+        {
+            var completedWorks = _complitedWorkStorageContract.GetList(fromDate, toDate);
+            return completedWorks
+                .Where(cw => cw.WorkId == workId)
+                .Count();
+        });
+
+        Task.WaitAll(incomingTask, outcomingTask);
+
+        return incomingTask.Result - outcomingTask.Result;
+    }
+
+    public void InsertWarehouse(WarehouseDataModel warehouseDataModel)
+    {
+        logger.LogInformation("Inserting warehouse: {@Warehouse}", warehouseDataModel);
+
+        if (warehouseDataModel == null)
+            throw new ArgumentNullException(nameof(warehouseDataModel));
+
+        if (warehouseStorageContract.GetElementById(warehouseDataModel.Id) != null)
+            throw new ElementExistsException($"Warehouse", warehouseDataModel.Id);
+
+        if (warehouseDataModel.WorkWarehouseDataModels == null || warehouseDataModel.WorkWarehouseDataModels.Count == 0)
+            throw new ValidationException("The value in the workWarehouseDataModels must include at least one warehouse.");
+
+        warehouseDataModel.Validate();
+
+        try
+        {
+            warehouseStorageContract.AddElement(warehouseDataModel);
+            logger.LogInformation("Warehouse {WarehouseId} inserted successfully", warehouseDataModel.Id);
+        }
+        catch (Exception ex)
+        {
+            throw new StorageException(ex);
+        }
+    }
+
+
+    public void UpdateWarehouse(WarehouseDataModel warehouseDataModel)
+    {
+        logger.LogInformation("Updating warehouse: {@Warehouse}", warehouseDataModel);
+
+        if (warehouseDataModel == null)
+            throw new ArgumentNullException(nameof(warehouseDataModel));
+
+        if (!Guid.TryParse(warehouseDataModel.Id, out _))
+            throw new ValidationException("Invalid warehouse ID format.");
+
+        var existingWarehouse = warehouseStorageContract.GetElementById(warehouseDataModel.Id);
+        if (existingWarehouse == null)
+            throw new ElementNotFoundException($"Warehouse with ID {warehouseDataModel.Id} not found.");
+
+        if (warehouseDataModel.WorkWarehouseDataModels == null || warehouseDataModel.WorkWarehouseDataModels.Count == 0)
+            throw new ValidationException("The warehouse must have at least one associated product.");
+
+        warehouseDataModel.Validate();
+
+        try
+        {
+            warehouseStorageContract.UpdElement(warehouseDataModel);
+            logger.LogInformation("Warehouse {WarehouseId} updated successfully", warehouseDataModel.Id);
+        }
+        catch (Exception ex)
+        {
+            throw new StorageException(ex);
+        }
+    }
+
+
+
+    public void DeleteWarehouse(string warehouseId)
+    {
+        logger.LogInformation("Deleting warehouse with ID: {WarehouseId}", warehouseId);
+
+        if (string.IsNullOrWhiteSpace(warehouseId))
+            throw new ArgumentNullException(nameof(warehouseId));
+
+        if (!warehouseId.IsGuid())
+            throw new ValidationException($"Invalid warehouse ID format: {warehouseId}");
+
+        var existingWarehouse = warehouseStorageContract.GetElementById(warehouseId);
+        if (existingWarehouse == null)
+            throw new ElementNotFoundException($"Warehouse with ID {warehouseId} not found.");
+
+        try
+        {
+            warehouseStorageContract.DelElement(warehouseId);
+            logger.LogInformation("Warehouse with ID {WarehouseId} deleted successfully.", warehouseId);
+        }
+        catch (Exception ex)
+        {
+            throw new StorageException(ex);
+        }
+    }
+}

TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/WorkBusinessLogicContract.cs

@@ -13,7 +13,7 @@ internal class WorkBusinessLogicContract(IWorkStorageContract _workStorageContra
     private ILogger logger = _logger;
     public List<WorkDataModel> GetAllWorks()
     {
-        _logger.LogInformation("Fetching all works.");
+        logger.LogInformation("Fetching all works.");
 
         var works = _workStorageContract.GetList();
 
@@ -22,14 +22,14 @@ internal class WorkBusinessLogicContract(IWorkStorageContract _workStorageContra
             throw new NullListException();
         }
 
-        _logger.LogInformation("Fetched {Count} works.", works.Count);
+        logger.LogInformation("Fetched {Count} works.", works.Count);
         return works;
     }
 
 
     public void InsertWork(WorkDataModel work)
     {
-        _logger.LogInformation("InsertWork: {@work}", work);
+        logger.LogInformation("InsertWork: {@work}", work);
 
         if (work == null)
             throw new ArgumentNullException(nameof(work));
@@ -56,7 +56,7 @@ internal class WorkBusinessLogicContract(IWorkStorageContract _workStorageContra
 
     public void UpdateWork(WorkDataModel work)
     {
-        _logger.LogInformation("Updating work: {@work}", work);
+        logger.LogInformation("Updating work: {@work}", work);
 
         if (work == null)
         {
@@ -96,7 +96,7 @@ internal class WorkBusinessLogicContract(IWorkStorageContract _workStorageContra
 
     public void DeleteWork(string workId)
     {
-        _logger.LogInformation("DeleteWork: {workId}", workId);
+        logger.LogInformation("DeleteWork: {workId}", workId);
 
         if (string.IsNullOrWhiteSpace(workId))
             throw new ArgumentNullException(nameof(workId));
@@ -119,7 +119,7 @@ internal class WorkBusinessLogicContract(IWorkStorageContract _workStorageContra
     }
     public WorkDataModel GetWorkByData(DateTime dataFrom, DateTime dataTo)
     {
-        _logger.LogInformation("Retrieving work data from {DataFrom} to {DataTo}", dataFrom, dataTo);
+        logger.LogInformation("Retrieving work data from {DataFrom} to {DataTo}", dataFrom, dataTo);
 
         if (dataFrom >= dataTo)
         {
@@ -145,7 +145,7 @@ internal class WorkBusinessLogicContract(IWorkStorageContract _workStorageContra
             throw new ElementNotFoundException($"No work found in the given period.");
         }
 
-        _logger.LogInformation("Found work: {WorkDescription} (ID: {WorkId})", latestWork.Description, latestWork.Id);
+        logger.LogInformation("Found work: {WorkDescription} (ID: {WorkId})", latestWork.Description, latestWork.Id);
 
         return latestWork;
     }

TwoFromTheCasketContracts/TwoFromTheCasketBusinessLogic/Implementation/WorkerComplitedWorkBusinessLogicContract.cs

@@ -1,149 +0,0 @@
-using Microsoft.Extensions.Logging;
-using TwoFromTheCasketContracts.BusinessLogicsContracts;
-using TwoFromTheCasketContracts.DataModels;
-using TwoFromTheCasketContracts.Exceptions;
-using TwoFromTheCasketContracts.StorageContracts;
-
-namespace TwoFromTheCasketBusinessLogic.Implementation;
-
-internal class WorkerComplitedWorkBusinessLogicContract(IWorkerComplitedWorkStorageContract _complitedWorkStorageContract, 
-    ILogger _logger) : IWorkerComplitedWorkBusinessLogicContract
-{
-    private IWorkerComplitedWorkStorageContract complitedWorkStorageContract = _complitedWorkStorageContract;
-    private ILogger logger = _logger;
-
-    public List<WorkerComplitedWorkDataModel> GetAllWorkerComplitedWorks()
-    {
-        logger.LogInformation("Fetching all worker completed works.");
-
-        var result = complitedWorkStorageContract.GetList();
-        if (result is null)
-        {
-            logger.LogError("No worker completed works found.");
-            throw new NullListException();
-        }
-
-        logger.LogInformation("Fetched {Count} worker completed works.", result.Count);
-        return result;
-    }
-
-    public List<WorkerComplitedWorkDataModel> GetWorkerComplitedWorksByWork(string workId)
-    {
-        logger.LogInformation("Fetching worker completed works by workId: {workId}", workId);
-
-        if (string.IsNullOrWhiteSpace(workId))
-        {
-            logger.LogError("Work ID is null or empty.");
-            throw new ArgumentNullException(nameof(workId));
-        }
-
-        if (!Guid.TryParse(workId, out _))
-        {
-            logger.LogError("Invalid work ID format: {workId}", workId);
-            throw new ValidationException("Invalid work ID format.");
-        }
-
-        var result = complitedWorkStorageContract.GetList(complitedWorkId: workId);
-        if (result is null)
-        {
-            logger.LogError("No completed works found for work ID: {workId}", workId);
-            throw new NullListException();
-        }
-
-        logger.LogInformation("Fetched {Count} worker completed works for workId: {workId}", result.Count, workId);
-        return result;
-    }
-    public List<WorkerComplitedWorkDataModel> GetWorkerComplitedWorksByWorker(string workerId)
-    {
-        logger.LogInformation("Fetching worker completed works by workerId: {workerId}", workerId);
-
-        if (string.IsNullOrWhiteSpace(workerId))
-        {
-            logger.LogError("Worker ID is null or empty.");
-            throw new ArgumentNullException(nameof(workerId));
-        }
-
-        if (!Guid.TryParse(workerId, out _))
-        {
-            logger.LogError("Invalid worker ID format: {workerId}", workerId);
-            throw new ValidationException("Invalid worker ID format.");
-        }
-
-        var result = complitedWorkStorageContract.GetList(workerId: workerId);
-        if (result is null)
-        {
-            logger.LogError("No completed works found for worker ID: {workerId}", workerId);
-            throw new NullListException();
-        }
-
-        logger.LogInformation("Fetched {Count} worker completed works for workerId: {workerId}", result.Count, workerId);
-        return result;
-    }
-
-    public void InsertWorkerComplitedWork(WorkerComplitedWorkDataModel workerComplitedWork)
-    {
-        logger.LogInformation("Inserting new worker completed work: {workerComplitedWork}", workerComplitedWork);
-
-        if (workerComplitedWork is null)
-        {
-            logger.LogError("Worker completed work data is null.");
-            throw new ArgumentNullException(nameof(workerComplitedWork));
-        }
-
-        if (!Guid.TryParse(workerComplitedWork.WorkerId, out _))
-            throw new ValidationException("Invalid worker ID format.");
-
-        if (!Guid.TryParse(workerComplitedWork.ComplitedWorkId, out _))
-            throw new ValidationException("Invalid completed work ID format.");
-
-        if (workerComplitedWork.NumberOfWorkingHours <= 0)
-            throw new ValidationException("Number of working hours must be greater than zero.");
-
-        complitedWorkStorageContract.AddElement(workerComplitedWork);
-        _logger.LogInformation("Worker completed work inserted successfully: {workerComplitedWork}", workerComplitedWork);
-    }
-
-    public void UpdateWorkerComplitedWork(WorkerComplitedWorkDataModel workerComplitedWork)
-    {
-        logger.LogInformation("Updating worker completed work: {workerComplitedWork}", workerComplitedWork);
-
-        if (workerComplitedWork is null)
-        {
-            logger.LogError("Worker completed work data is null.");
-            throw new ArgumentNullException(nameof(workerComplitedWork));
-        }
-
-        if (!Guid.TryParse(workerComplitedWork.WorkerId, out _))
-            throw new ValidationException("Invalid worker ID format.");
-
-        if (!Guid.TryParse(workerComplitedWork.ComplitedWorkId, out _))
-            throw new ValidationException("Invalid completed work ID format.");
-
-        if (workerComplitedWork.NumberOfWorkingHours <= 0)
-            throw new ValidationException("Number of working hours must be greater than zero.");
-
-        complitedWorkStorageContract.UpdElement(workerComplitedWork);
-        logger.LogInformation("Worker completed work updated successfully: {workerComplitedWork}", workerComplitedWork);
-    }
-
-    public void DeleteWorkerComplitedWork(string workerComplitedWorkId)
-    {
-        logger.LogInformation("Deleting worker completed work: {workerComplitedWorkId}", workerComplitedWorkId);
-
-        if (string.IsNullOrWhiteSpace(workerComplitedWorkId))
-        {
-            logger.LogError("Worker completed work ID is null or empty.");
-            throw new ArgumentNullException(nameof(workerComplitedWorkId));
-        }
-
-        if (!Guid.TryParse(workerComplitedWorkId, out _))
-        {
-            logger.LogError("Invalid worker completed work ID format: {workerComplitedWorkId}", workerComplitedWorkId);
-            throw new ValidationException("Invalid worker completed work ID format.");
-        }
-
-        complitedWorkStorageContract.DelElement(workerComplitedWorkId);
-        logger.LogInformation("Worker completed work deleted successfully: {workerComplitedWorkId}", workerComplitedWorkId);
-    }
-
-}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/AdapterContracts/ISupplyAdapter.cs

@@ -0,0 +1,14 @@
+using TwoFromTheCasketContracts.AdapterContracts.OperationResponses;
+using TwoFromTheCasketContracts.BindingModels;
+
+namespace TwoFromTheCasketContracts.AdapterContracts;
+
+public interface ISupplyAdapter
+{
+    SupplyOperationResponse GetList();
+    SupplyOperationResponse GetElement(string id);
+
+    SupplyOperationResponse Register(SupplyBindingModel model);
+    SupplyOperationResponse ChangeInfo(SupplyBindingModel model);
+    SupplyOperationResponse Remove(string id);
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/AdapterContracts/IWarehouseAdapter.cs

@@ -0,0 +1,14 @@
+using TwoFromTheCasketContracts.AdapterContracts.OperationResponses;
+using TwoFromTheCasketContracts.BindingModels;
+
+namespace TwoFromTheCasketContracts.AdapterContracts;
+
+public interface IWarehouseAdapter
+{
+    WarehouseOperationResponse GetList();
+    WarehouseOperationResponse GetElement(string id);
+
+    WarehouseOperationResponse Register(WarehouseBindingModel model);
+    WarehouseOperationResponse ChangeInfo(WarehouseBindingModel model);
+    WarehouseOperationResponse Remove(string id);
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/AdapterContracts/OperationResponses/SupplyOperationResponse.cs

@@ -0,0 +1,19 @@
+using TwoFromTheCasketContracts.Infastructure;
+using TwoFromTheCasketContracts.ViewModels;
+
+namespace TwoFromTheCasketContracts.AdapterContracts.OperationResponses;
+
+public class SupplyOperationResponse : OperationResponse
+{
+    public static SupplyOperationResponse OK(List<SupplyViewModel> data) => OK<SupplyOperationResponse, List<SupplyViewModel>>(data);
+
+    public static SupplyOperationResponse OK(SupplyViewModel data) => OK<SupplyOperationResponse, SupplyViewModel>(data);
+
+    public static SupplyOperationResponse NoContent() => NoContent<SupplyOperationResponse>();
+
+    public static SupplyOperationResponse BadRequest(string message) => BadRequest<SupplyOperationResponse>(message);
+
+    public static SupplyOperationResponse NotFound(string message) => NotFound<SupplyOperationResponse>(message);
+
+    public static SupplyOperationResponse InternalServerError(string message) => InternalServerError<SupplyOperationResponse>(message);
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/AdapterContracts/OperationResponses/WarehouseOperationResponse.cs

@@ -0,0 +1,19 @@
+using TwoFromTheCasketContracts.Infastructure;
+using TwoFromTheCasketContracts.ViewModels;
+
+namespace TwoFromTheCasketContracts.AdapterContracts.OperationResponses;
+
+public class WarehouseOperationResponse : OperationResponse
+{
+    public static WarehouseOperationResponse OK(List<WarehouseViewModel> data) => OK<WarehouseOperationResponse, List<WarehouseViewModel>>(data);
+
+    public static WarehouseOperationResponse OK(WarehouseViewModel data) => OK<WarehouseOperationResponse, WarehouseViewModel>(data);
+
+    public static WarehouseOperationResponse NoContent() => NoContent<WarehouseOperationResponse>();
+
+    public static WarehouseOperationResponse BadRequest(string message) => BadRequest<WarehouseOperationResponse>(message);
+
+    public static WarehouseOperationResponse NotFound(string message) => NotFound<WarehouseOperationResponse>(message);
+
+    public static WarehouseOperationResponse InternalServerError(string message) => InternalServerError<WarehouseOperationResponse>(message);
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/BindingModels/SupplyBindingModel.cs

@@ -0,0 +1,9 @@
+namespace TwoFromTheCasketContracts.BindingModels;
+
+public class SupplyBindingModel
+{
+    public string? Id { get; set; }
+    public string? WarehouseId { get; set; }
+    public DateTime SupplyDate { get; set; }
+    public List<WorkSupplyBindingModel>? Works { get; set; }
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/BindingModels/WarehouseBindingModel.cs

@@ -0,0 +1,11 @@
+using TwoFromTheCasketContracts.DataModels;
+
+namespace TwoFromTheCasketContracts.BindingModels;
+
+public class WarehouseBindingModel
+{
+    public string? Id { get; set; }
+    public string? Name { get; set; }
+    public string? Location { get; set; }
+    public List<WorkWarehouseDataModel> WorkWarehouseDataModels { get; set; }
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/BindingModels/WorkSupplyBindingModel.cs

@@ -0,0 +1,8 @@
+namespace TwoFromTheCasketContracts.BindingModels;
+
+public class WorkSupplyBindingModel
+{
+    public string? WorkId { get; set; }
+    public string? SupplyId { get; set; }
+    public double Quantity { get; set; }
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/BindingModels/WorkWarehouseBindingModel.cs

@@ -0,0 +1,8 @@
+namespace TwoFromTheCasketContracts.BindingModels;
+
+public class WorkWarehouseBindingModel
+{
+    public string? WorkId { get; set; }
+    public string? WarehouseId { get; set; }
+    public double Quantity { get; set; }
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/BusinessLogicsContracts/IComplitedWorkBusinessLogicContract.cs

@@ -6,7 +6,7 @@ public interface IComplitedWorkBusinessLogicContract
     List<ComplitedWorkDataModel> GetComplitedWorksByRoomByPeriod(string roomId, DateTime fromDate, DateTime toDate);
     List<ComplitedWorkDataModel> GetComplitedWorksByWorkTypeByPeriod(string workId, DateTime fromDate, DateTime toDate);
     List<ComplitedWorkDataModel> GetComplitedWorksByWorkerByPeriod(string workerId, DateTime fromDate, DateTime toDate);
-
+    public int CalculateProfitByPeriod(DateTime fromDate, DateTime toDate);
     ComplitedWorkDataModel GetComplitedWorkByData(string data);
 
     void InsertComplitedWork(ComplitedWorkDataModel complitedWorkDataModel);

TwoFromTheCasketContracts/TwoFromTheCasketContracts/BusinessLogicsContracts/IRoomBusinessLogicContract.cs

@@ -5,7 +5,7 @@ public interface IRoomBusinessLogicContract
     List<RoomDataModel> GetAllRooms();
     List<RoomDataModel> GetRoomsByOwner(string ownerName);
     List<RoomDataModel> GetRoomsByAddress(string address);
-
+    List<RoomHistoryDataModel> GetRoomHistory(string roomId);
     RoomDataModel GetRoomByData(string data);
 
     void InsertRoom(RoomDataModel roomDataModel);

TwoFromTheCasketContracts/TwoFromTheCasketContracts/BusinessLogicsContracts/IRoomHistoryBusinessLogicContract.cs

@@ -1,9 +0,0 @@
-using TwoFromTheCasketContracts.DataModels;
-namespace TwoFromTheCasketContracts.BusinessLogicsContracts;
-public interface IRoomHistoryBusinessLogicContract
-{
-    List<RoomHistoryDataModel> GetRoomHistory(string roomId);
-    RoomHistoryDataModel GetLatestRoomHistory(string roomId);
-
-    void AddRoomHistory(RoomHistoryDataModel roomHistoryDataModel);
-}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/BusinessLogicsContracts/ISupplyBuisnessLogicContract.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContracts.DataModels;
+
+namespace TwoFromTheCasketContracts.BusinessLogicsContracts;
+
+public interface ISupplyBuisnessLogicContract
+{
+    List<SupplyDataModel> GetSuppliesByPeriod(DateTime fromDate, DateTime toDate);
+    List<SupplyDataModel> GetSuppliesByWarehouseId(string warehouseId);
+    SupplyDataModel GetSupplyByData(string data);
+    public int CountSupplyByPeriod(string workId, DateTime fromDate, DateTime toDate);
+
+    void InsertSupply(SupplyDataModel supplyDataModel);
+    void DeleteSupply(string id);
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/BusinessLogicsContracts/IWarehouseBuisnessLogicContract.cs

@@ -0,0 +1,14 @@
+using TwoFromTheCasketContracts.DataModels;
+namespace TwoFromTheCasketContracts.BusinessLogicsContracts;
+
+public interface IWarehouseBuisnessLogicContract
+{
+    List<WarehouseDataModel> GetWarehousesByName(string WarehouseName);
+    List<WarehouseDataModel> GetWarehousesByLocation(string WarehouseLocation);
+    WarehouseDataModel GetWarehouseByData(string data);
+    public int CountSupplyRemainderByPeriod(string workId, DateTime fromDate, DateTime toDate);
+    void InsertWarehouse(WarehouseDataModel warehouseDataModel);
+    void UpdateWarehouse(WarehouseDataModel warehouseDataModel);
+    void DeleteWarehouse(string id);
+
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/BusinessLogicsContracts/IWorkerComplitedWorkBusinessLogicContract.cs

@@ -1,12 +0,0 @@
-using TwoFromTheCasketContracts.DataModels;
-namespace TwoFromTheCasketContracts.BusinessLogicsContracts;
-public interface IWorkerComplitedWorkBusinessLogicContract
-{
-    List<WorkerComplitedWorkDataModel> GetWorkerComplitedWorksByWorker(string workerId);
-    List<WorkerComplitedWorkDataModel> GetWorkerComplitedWorksByWork(string workId);
-
-
-    void InsertWorkerComplitedWork(WorkerComplitedWorkDataModel workerComplitedWorkDataModel);
-    void UpdateWorkerComplitedWork(WorkerComplitedWorkDataModel workerComplitedWorkDataModel);
-    void DeleteWorkerComplitedWork(string id);
-}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/DataModels/ComplitedWorkDataModel.cs

@@ -3,7 +3,7 @@ using TwoFromTheCasketContracts.Exceptions;
 using TwoFromTheCasketContracts.Infastructure;
 namespace TwoFromTheCasketContracts.DataModels;
 
-public class ComplitedWorkDataModel(string id, string workId, string roomId, List<WorkerComplitedWorkDataModel> workers ) :IValidation
+public class ComplitedWorkDataModel(string id, string workId, string roomId, List<WorkerComplitedWorkDataModel> workers) :IValidation
 {
     public string Id { get; private set; } = id;
     public string WorkId { get; private set; } = workId;

TwoFromTheCasketContracts/TwoFromTheCasketContracts/DataModels/SupplyDataModel.cs

@@ -0,0 +1,31 @@
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketContracts.Extensions;
+using TwoFromTheCasketContracts.Infastructure;
+
+namespace TwoFromTheCasketContracts.DataModels;
+
+public class SupplyDataModel : IValidation
+{
+    public string Id { get; private set; }
+    public string WarehouseId { get; private set; }
+    public DateTime SupplyDate { get; private set; }
+    public List<WorkSupplyDataModel> Works { get; private set; }
+
+    public SupplyDataModel(string id, string warehouseId, DateTime supplyDate, List<WorkSupplyDataModel> works)
+    {
+        Id = id;
+        WarehouseId = warehouseId;
+        SupplyDate = supplyDate;
+        Works = works;
+    }
+    public SupplyDataModel() { }
+    public void Validate()
+    {
+        if (Id.IsEmpty()) throw new ValidationException("Field Id is empty");
+        if (!Id.IsGuid()) throw new ValidationException("The value in the field Id is not a unique identifier");
+        if (WarehouseId.IsEmpty()) throw new ValidationException("Field WarehouseId is empty");
+        if (!WarehouseId.IsGuid()) throw new ValidationException("The value in the field WarehouseId is not a unique identifier");
+        if ((Works?.Count ?? 0) == 0)
+            throw new ValidationException("The value in the Works must include work");
+    }
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/DataModels/WarehouseDataModel.cs

@@ -0,0 +1,35 @@
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketContracts.Extensions;
+using TwoFromTheCasketContracts.Infastructure;
+
+namespace TwoFromTheCasketContracts.DataModels;
+
+public class WarehouseDataModel : IValidation
+{
+    public string Id { get; private set; }
+    public string Name { get; private set; } 
+    public string Location { get; private set; } 
+    public List<WorkWarehouseDataModel> WorkWarehouseDataModels { get; private set; }
+
+    public WarehouseDataModel(string id, string name, string location, List<WorkWarehouseDataModel> workWarehouseDataModels)
+    {
+        Id = id;
+        Name = name;
+        Location = location;
+        WorkWarehouseDataModels = workWarehouseDataModels;
+    }
+
+    public WarehouseDataModel() : this(string.Empty, string.Empty, string.Empty, new List<WorkWarehouseDataModel>()) { }
+
+
+    public void Validate()
+    {
+        if (Id.IsEmpty()) throw new ValidationException("Field Id is empty");
+        if (!Id.IsGuid()) throw new ValidationException("The value in the field Id is not a unique identifier");
+        if (Name.IsEmpty()) throw new ValidationException("Field Name is empty");
+        if (Location.IsEmpty()) throw new ValidationException("Field Location is empty");
+        if ((WorkWarehouseDataModels?.Count ?? 0) == 0)
+            throw new ValidationException("The value in the workWarehouseDataModels must include warehouse");
+    }
+}
+

TwoFromTheCasketContracts/TwoFromTheCasketContracts/DataModels/WorkDataModel.cs

@@ -24,7 +24,5 @@ public class WorkDataModel(string id, TypeWork type, string description, DateTim
             throw new ValidationException("Field Description is empty");
         if (Date < DateTime.Now)
             throw new ValidationException("Field Date is earlier than today");
-        
-
     }
 }

TwoFromTheCasketContracts/TwoFromTheCasketContracts/DataModels/WorkSupplyDataModel.cs

@@ -0,0 +1,21 @@
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketContracts.Extensions;
+using TwoFromTheCasketContracts.Infastructure;
+
+namespace TwoFromTheCasketContracts.DataModels;
+
+public class WorkSupplyDataModel(string workId, string supplyId, double quantity) : IValidation
+{
+    public string WorkId { get; private set; } = workId;
+    public string SupplyId { get; private set; } = supplyId;
+    public double Quantity { get; private set; } = quantity;
+
+    public void Validate()
+    {
+        if (WorkId.IsEmpty()) throw new ValidationException("Field WorkId is empty");
+        if (!WorkId.IsGuid()) throw new ValidationException("The value in the field WorkId is not a unique identifier");
+        if (SupplyId.IsEmpty()) throw new ValidationException("Field SupplyId is empty");
+        if (!SupplyId.IsGuid()) throw new ValidationException("The value in the field SupplyId is not a unique identifier");
+        if (Quantity <= 0) throw new ValidationException("Field Quantity must be greater than zero");
+    }
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/DataModels/WorkWarehouseDataModel.cs

@@ -0,0 +1,26 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketContracts.Extensions;
+using TwoFromTheCasketContracts.Infastructure;
+
+namespace TwoFromTheCasketContracts.DataModels;
+
+public class WorkWarehouseDataModel(string workId, string warehouseId, double quantity) : IValidation
+{
+    public string WorkId { get; private set; } = workId;
+    public string WarehouseId { get; private set; } = warehouseId;
+    public double Quantity { get; private set; } = quantity;
+
+    public void Validate()
+    {
+        if (WorkId.IsEmpty()) throw new ValidationException("Field WorkId is empty");
+        if (!WorkId.IsGuid()) throw new ValidationException("The value in the field WorkId is not a unique identifier");
+        if (WarehouseId.IsEmpty()) throw new ValidationException("Field WarehouseId is empty");
+        if (!WarehouseId.IsGuid()) throw new ValidationException("The value in the field WarehouseId is not a unique identifier");
+        if (Quantity <= 0) throw new ValidationException("Field Quantity must be greater than zero");
+    }
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/ISupplyStorageContract.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContracts.DataModels;
+
+namespace TwoFromTheCasketContracts.StorageContracts;
+
+public interface ISupplyStorageContract
+{
+    List<SupplyDataModel> GetList(DateTime startDate, DateTime endDate, string? warehouseId = null);
+    SupplyDataModel? GetElementById(string id);
+    void AddElement(SupplyDataModel supplyDataModel);
+    void DelElement(string id);
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/IWarehouseStorageContract.cs

@@ -0,0 +1,20 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContracts.DataModels;
+
+namespace TwoFromTheCasketContracts.StorageContracts;
+
+public interface IWarehouseStorageContract
+{
+    List<WarehouseDataModel> GetListByLocation(string Location);
+    List<WarehouseDataModel> GetListByName(string Name);
+    WarehouseDataModel? GetElementById(string id);
+    void AddElement(WarehouseDataModel warehouseDataModel);
+    void UpdElement(WarehouseDataModel warehouseDataModel);
+    void DelElement(string id);
+    bool CheckWorks(ComplitedWorkDataModel workDataModel);
+    void ReserveWorksForComplitedWork(ComplitedWorkDataModel workDataModel);
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/IWorkSupplyStorageContract.cs

@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContracts.DataModels;
+
+namespace TwoFromTheCasketContracts.StorageContracts;
+
+public interface IWorkSupplyStorageContract
+{
+    List<WorkSupplyDataModel> GetListBySupplyId(string supplyId);
+    void AddElement(WorkSupplyDataModel workSupply);
+    void DelElement(string workId, string supplyId);
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/IWorkWarehouseStorageContract.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using TwoFromTheCasketContracts.DataModels;
+
+namespace TwoFromTheCasketContracts.StorageContracts;
+
+public interface IWorkWarehouseStorageContract
+{
+    List<WorkWarehouseDataModel> GetListByWorkId(string workId);
+    List<WorkWarehouseDataModel> GetListByWarehouseId(string warehouseId);
+    WorkWarehouseDataModel? GetElementByWorkAndWarehouse(string workId, string warehouseId);
+    void AddElement(WorkWarehouseDataModel workWarehouseDataModel);
+    void UpdElement(WorkWarehouseDataModel workWarehouseDataModel);
+    void DelElement(string workId, string warehouseId);
+}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/StorageContracts/IWorkerComplitedWorkStorageContract.cs

@@ -1,10 +0,0 @@
-using TwoFromTheCasketContracts.DataModels;
-namespace TwoFromTheCasketContracts.StorageContracts;
-public interface IWorkerComplitedWorkStorageContract
-{
-    List<WorkerComplitedWorkDataModel> GetList(string? workerId = null, string? complitedWorkId = null);
-    WorkerComplitedWorkDataModel? GetElementById(string id);
-    void AddElement(WorkerComplitedWorkDataModel workerComplitedWorkDataModel);
-    void UpdElement(WorkerComplitedWorkDataModel workerComplitedWorkDataModel);
-    void DelElement(string id);
-}

TwoFromTheCasketContracts/TwoFromTheCasketContracts/ViewModels/SupplyViewModel.cs

@@ -0,0 +1,10 @@
+namespace TwoFromTheCasketContracts.ViewModels;
+
+public class SupplyViewModel
+{
+    public required string Id { get; set; }
+    public required string WarehouseId { get; set; }
+    public DateTime SupplyDate { get; set; }
+    public required List<WorkSupplyViewModel> Works { get; set; }
+}
+

TwoFromTheCasketContracts/TwoFromTheCasketContracts/ViewModels/WarehouseViewModel.cs

@@ -0,0 +1,10 @@
+namespace TwoFromTheCasketContracts.ViewModels;
+
+public class WarehouseViewModel
+{
+    public required string Id { get; set; }
+    public required string Name { get; set; }
+    public required string Location { get; set; }
+    public required List<WorkWarehouseViewModel> WorkWarehouseDataModels { get; set; }
+}
+

TwoFromTheCasketContracts/TwoFromTheCasketContracts/ViewModels/WorkSupplyViewModel.cs

@@ -0,0 +1,9 @@
+namespace TwoFromTheCasketContracts.ViewModels;
+
+public class WorkSupplyViewModel
+{
+    public required string WorkId { get; set; }
+    public required string SupplyId { get; set; }
+    public double Quantity { get; set; }
+}
+

TwoFromTheCasketContracts/TwoFromTheCasketContracts/ViewModels/WorkWarehouseViewModel.cs

@@ -0,0 +1,9 @@
+
+namespace TwoFromTheCasketContracts.ViewModels;
+
+public class WorkWarehouseViewModel
+{
+    public required string WorkId { get; set; }
+    public required string WarehouseId { get; set; }
+    public double Quantity { get; set; }
+}

TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/ComplitedWorkStorageContract.cs

@@ -11,11 +11,14 @@ namespace TwoFromTheCasketDatabase.Implementations;
 public class ComplitedWorkStorageContract : IComplitedWorkStorageContract
 {
     private readonly TwoFromTheCasketDbContext _dbContext;
+    private readonly IWarehouseStorageContract _warehouseStorage;
     private readonly Mapper _mapper;
 
-    public ComplitedWorkStorageContract(TwoFromTheCasketDbContext context)
+    public ComplitedWorkStorageContract(TwoFromTheCasketDbContext context, IWarehouseStorageContract warehouseStorage)
     {
         _dbContext = context;
+        _warehouseStorage = warehouseStorage;
+
         var conf = new MapperConfiguration(cfg =>
         {
             cfg.CreateMap<ComplitedWork, ComplitedWorkDataModel>()
@@ -114,37 +117,20 @@ public class ComplitedWorkStorageContract : IComplitedWorkStorageContract
     {
         try
         {
-            if (complitedWorkDataModel.Workers == null || complitedWorkDataModel.Workers.Count == 0)
+            bool m = _warehouseStorage.CheckWorks(complitedWorkDataModel);
+            if (!_warehouseStorage.CheckWorks(complitedWorkDataModel))
             {
-                throw new ValidationException("The value in the Workers must include workers");
+                throw new ElementNotFoundException("Not enough work available in warehouses.");
             }
 
-            if (!_dbContext.Rooms.Any(x => x.Id == complitedWorkDataModel.RoomId))
-            {
-                throw new ElementNotFoundException($"Room with ID {complitedWorkDataModel.RoomId} not found.");
-            }
-
-            var complitedWork = _mapper.Map<ComplitedWork>(complitedWorkDataModel);
-            _dbContext.ComplitedWorks.Add(complitedWork);
-
-            foreach (var worker in complitedWorkDataModel.Workers)
-            {
-                _dbContext.WorkerComplitedWorks.Add(new WorkerComplitedWork
-                {
-                    WorkerId = worker.WorkerId,
-                    ComplitedWorkId = complitedWork.Id,
-                    NumberOfWorkingHours = worker.NumberOfWorkingHours
-                });
-            }
+            _warehouseStorage.ReserveWorksForComplitedWork(complitedWorkDataModel);
 
+            _dbContext.ComplitedWorks.Add(_mapper.Map<ComplitedWork>(complitedWorkDataModel));
             _dbContext.SaveChanges();
         }
-        catch (ValidationException)
-        {
-            throw;
-        }
         catch (ElementNotFoundException)
         {
+            _dbContext.ChangeTracker.Clear();
             throw;
         }
         catch (DbUpdateException ex) when (ex.InnerException is PostgresException { ConstraintName: "PK_ComplitedWorks" })
@@ -159,10 +145,6 @@ public class ComplitedWorkStorageContract : IComplitedWorkStorageContract
         }
     }
 
-
-
-
-
     public void DelElement(string id)
     {
         try

TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/SupplyStorageContract.cs

@@ -0,0 +1,185 @@
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using Npgsql;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketContracts.StorageContracts;
+using TwoFromTheCasketDatabase.Models;
+
+namespace TwoFromTheCasketDatabase.Implementations;
+
+public class SupplyStorageContract : ISupplyStorageContract
+{
+    private readonly TwoFromTheCasketDbContext _dbContext;
+    private readonly IMapper _mapper;
+
+    public SupplyStorageContract(TwoFromTheCasketDbContext context)
+    {
+        _dbContext = context;
+
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.CreateMap<Supply, SupplyDataModel>()
+            .ConstructUsing(s =>
+                new SupplyDataModel(
+                 s.Id,
+                s.WarehouseId,
+                s.SupplyDate,
+                s.Works.Select(ws =>
+                    new WorkSupplyDataModel(ws.WorkId, ws.SupplyId, (double)ws.Quantity))
+                .ToList()
+            ));
+            cfg.CreateMap<SupplyDataModel, Supply>();
+            cfg.CreateMap<Work_Supply, WorkSupplyDataModel>()
+                .ConstructUsing(ws =>
+                    new WorkSupplyDataModel(ws.WorkId, ws.SupplyId, (double)ws.Quantity));
+            cfg.CreateMap<WorkSupplyDataModel, Work_Supply>()
+                .ConstructUsing(wsd => new Work_Supply
+                {
+                    WorkId = wsd.WorkId,
+                    SupplyId = wsd.SupplyId,
+                    Quantity = (decimal)wsd.Quantity
+                });
+        });
+
+        _mapper = new Mapper(config);
+    }
+
+    public List<SupplyDataModel> GetList(DateTime startDate, DateTime endDate, string? warehouseId = null)
+    {
+        try
+        {
+            var query = _dbContext.Supplies
+                .Include(x => x.Works)
+                .Where(x => x.SupplyDate >= startDate && x.SupplyDate <= endDate);
+
+            if (!string.IsNullOrEmpty(warehouseId))
+                query = query.Where(x => x.WarehouseId == warehouseId);
+
+            return query
+                .Select(x => _mapper.Map<SupplyDataModel>(x))
+                .ToList();
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public SupplyDataModel? GetElementById(string id)
+    {
+        try
+        {
+            var entity = _dbContext.Supplies
+                       .Include(s => s.Works)
+                       .FirstOrDefault(s => s.Id == id);
+
+            return _mapper.Map<SupplyDataModel>(entity);
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public void AddElement(SupplyDataModel supplyDataModel)
+    {
+        try
+        {
+            var entity = new Supply
+            {
+                Id = supplyDataModel.Id,
+                WarehouseId = supplyDataModel.WarehouseId,
+                SupplyDate = supplyDataModel.SupplyDate
+            };
+
+            _dbContext.Supplies.Add(entity);
+
+            foreach (var ws in supplyDataModel.Works)
+            {
+                if (!_dbContext.WorkSupplyies.Local.Any(x =>
+                    x.WorkId == ws.WorkId && x.SupplyId == supplyDataModel.Id))
+                {
+                    _dbContext.WorkSupplyies.Add(new Work_Supply
+                    {
+                        WorkId = ws.WorkId,
+                        SupplyId = supplyDataModel.Id,
+                        Quantity = (decimal)ws.Quantity
+                    });
+                }
+
+                var existing = _dbContext.WorkWarehouses
+                    .FirstOrDefault(x => x.WorkId == ws.WorkId && x.WarehouseId == supplyDataModel.WarehouseId);
+
+                if (existing != null)
+                {
+                    existing.Quantity += (decimal)ws.Quantity;
+                    _dbContext.WorkWarehouses.Update(existing);
+                }
+                else
+                {
+                    _dbContext.WorkWarehouses.Add(new Work_Warehouse
+                    {
+                        WorkId = ws.WorkId,
+                        WarehouseId = supplyDataModel.WarehouseId,
+                        Quantity = (decimal)ws.Quantity
+                    });
+                }
+            }
+
+            _dbContext.SaveChanges();
+        }
+        catch (DbUpdateException ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+
+    public void DelElement(string id)
+    {
+        try
+        {
+            var supply = _dbContext.Supplies
+                .Include(x => x.Works)
+                .FirstOrDefault(x => x.Id == id)
+                ?? throw new ElementNotFoundException(id);
+
+            foreach (var ws in supply.Works)
+            {
+                var warehouseItem = _dbContext.WorkWarehouses
+                    .FirstOrDefault(x => x.WarehouseId == supply.WarehouseId && x.WorkId == ws.WorkId);
+
+                if (warehouseItem != null)
+                {
+                    warehouseItem.Quantity -= ws.Quantity;
+                    if (warehouseItem.Quantity < 0)
+                        warehouseItem.Quantity = 0;
+                }
+            }
+
+            _dbContext.WorkSupplyies.RemoveRange(supply.Works);
+            _dbContext.Supplies.Remove(supply);
+
+            _dbContext.SaveChanges();
+        }
+        catch (ElementNotFoundException)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+}

TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/WarehouseStorageContract.cs

@@ -0,0 +1,221 @@
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using Npgsql;
+using TwoFromTheCasketContracts.BindingModels;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketContracts.StorageContracts;
+using TwoFromTheCasketContracts.ViewModels;
+using TwoFromTheCasketDatabase.Models;
+
+namespace TwoFromTheCasketDatabase.Implementations
+{
+    public class WarehouseStorageContract : IWarehouseStorageContract
+    {
+        private readonly TwoFromTheCasketDbContext _dbContext;
+        private readonly Mapper _mapper;
+
+        public WarehouseStorageContract(TwoFromTheCasketDbContext context)
+        {
+            _dbContext = context;
+            var conf = new MapperConfiguration(cfg =>
+            {
+                cfg.CreateMap<Warehouse, WarehouseDataModel>();
+                cfg.CreateMap<WarehouseDataModel, Warehouse>();
+
+                cfg.CreateMap<WorkWarehouseBindingModel, WorkWarehouseDataModel>();
+                cfg.CreateMap<WarehouseBindingModel, WarehouseDataModel>();
+
+                cfg.CreateMap<WorkWarehouseDataModel, WorkWarehouseViewModel>();
+                cfg.CreateMap<WarehouseDataModel, WarehouseViewModel>();
+            });
+            _mapper = new Mapper(conf);
+        }
+
+        public List<WarehouseDataModel> GetListByLocation(string location)
+        {
+            try
+            {
+                return [.. _dbContext.Warehouses
+                    .Where(w => w.Location == location)
+                    .Select(w => _mapper.Map<WarehouseDataModel>(w))];
+            }
+            catch (Exception ex)
+            {
+                _dbContext.ChangeTracker.Clear();
+                throw new StorageException(ex);
+            }
+        }
+
+        public List<WarehouseDataModel> GetListByName(string name)
+        {
+            try
+            {
+                return [.. _dbContext.Warehouses
+                    .Where(w => w.Name == name)
+                    .Select(w => _mapper.Map<WarehouseDataModel>(w))];
+            }
+            catch (Exception ex)
+            {
+                _dbContext.ChangeTracker.Clear();
+                throw new StorageException(ex);
+            }
+        }
+
+        public WarehouseDataModel? GetElementById(string id)
+        {
+            try
+            {
+                var warehouse = _dbContext.Warehouses.FirstOrDefault(w => w.Id == id);
+                return _mapper.Map<WarehouseDataModel>(warehouse);
+            }
+            catch (Exception ex)
+            {
+                _dbContext.ChangeTracker.Clear();
+                throw new StorageException(ex);
+            }
+        }
+
+        public void AddElement(WarehouseDataModel warehouseDataModel)
+        {
+            try
+            {
+                _dbContext.Warehouses.Add(_mapper.Map<Warehouse>(warehouseDataModel));
+                _dbContext.SaveChanges();
+            }
+            catch (DbUpdateException ex) when (ex.InnerException is PostgresException { ConstraintName: "IX_Warehouses_Name_Location" })
+            {
+                _dbContext.ChangeTracker.Clear();
+                throw new ElementExistsException("Name", warehouseDataModel.Name);
+            }
+            catch (Exception ex)
+            {
+                _dbContext.ChangeTracker.Clear();
+                throw new StorageException(ex);
+            }
+        }
+
+        public void UpdElement(WarehouseDataModel warehouseDataModel)
+        {
+            try
+            {
+                var existingWarehouse = _dbContext.Warehouses
+                    .FirstOrDefault(w => w.Id == warehouseDataModel.Id)
+                    ?? throw new ElementNotFoundException(warehouseDataModel.Id);
+
+                _dbContext.Warehouses.Update(_mapper.Map(warehouseDataModel, existingWarehouse));
+                _dbContext.SaveChanges();
+            }
+            catch (ElementNotFoundException)
+            {
+                _dbContext.ChangeTracker.Clear();
+                throw;
+            }
+            catch (DbUpdateException ex) when (ex.InnerException is PostgresException { ConstraintName: "IX_Warehouses_Name_Location" })
+            {
+                _dbContext.ChangeTracker.Clear();
+                throw new ElementExistsException("Name", warehouseDataModel.Name);
+            }
+            catch (Exception ex)
+            {
+                _dbContext.ChangeTracker.Clear();
+                throw new StorageException(ex);
+            }
+        }
+
+        public void DelElement(string id)
+        {
+            try
+            {
+                var warehouse = _dbContext.Warehouses.FirstOrDefault(w => w.Id == id)
+                    ?? throw new ElementNotFoundException(id);
+
+                _dbContext.Warehouses.Remove(warehouse);
+                _dbContext.SaveChanges();
+            }
+            catch (ElementNotFoundException)
+            {
+                _dbContext.ChangeTracker.Clear();
+                throw;
+            }
+            catch (Exception ex)
+            {
+                _dbContext.ChangeTracker.Clear();
+                throw new StorageException(ex);
+            }
+        }
+
+        public bool CheckWorks(ComplitedWorkDataModel workDataModel)
+        {
+            try
+            {
+                var requiredWork = _dbContext.Works
+                    .FirstOrDefault(w => w.Id == workDataModel.WorkId)
+                    ?? throw new ElementNotFoundException(workDataModel.WorkId);
+
+                var availableWorkQuantities = _dbContext.WorkWarehouses
+                    .Where(ww => ww.WorkId == requiredWork.Id)
+                    .ToList();
+
+                var totalAvailable = availableWorkQuantities.Sum(ww => ww.Quantity);
+
+                return totalAvailable > 0;
+            }
+            catch (ElementNotFoundException)
+            {
+                _dbContext.ChangeTracker.Clear();
+                throw;
+            }
+            catch (Exception ex)
+            {
+                _dbContext.ChangeTracker.Clear();
+                throw new StorageException(ex);
+            }
+        }
+
+        public void ReserveWorksForComplitedWork(ComplitedWorkDataModel workDataModel)
+        {
+            try
+            {
+                var requiredWork = _dbContext.Works
+                    .FirstOrDefault(w => w.Id == workDataModel.WorkId)
+                    ?? throw new ElementNotFoundException(workDataModel.WorkId);
+
+                var workStocks = _dbContext.WorkWarehouses
+                    .Where(ww => ww.WorkId == requiredWork.Id)
+                    .OrderByDescending(ww => ww.Quantity)
+                    .ToList();
+
+                int requiredQuantity = 1;
+
+                foreach (var stock in workStocks)
+                {
+                    if (requiredQuantity <= 0) break;
+
+                    int taken = (int)Math.Min(stock.Quantity, requiredQuantity);
+                    stock.Quantity -= taken;
+                    requiredQuantity -= taken;
+                }
+
+                if (requiredQuantity > 0)
+                {
+                    throw new ElementNotFoundException("Not enough work");
+                }
+
+                _dbContext.SaveChanges();
+            }
+            catch (ElementNotFoundException)
+            {
+                _dbContext.ChangeTracker.Clear();
+                throw;
+            }
+            catch (Exception ex)
+            {
+                _dbContext.ChangeTracker.Clear();
+                throw new StorageException(ex);
+            }
+        }
+
+
+    }
+}

TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/WorkSupplyStorageContract.cs

@@ -0,0 +1,122 @@
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketContracts.StorageContracts;
+using TwoFromTheCasketDatabase.Models;
+
+namespace TwoFromTheCasketDatabase.Implementations;
+
+public class WorkSupplyStorageContract : IWorkSupplyStorageContract
+{
+    private readonly TwoFromTheCasketDbContext _dbContext;
+    private readonly Mapper _mapper;
+
+    public WorkSupplyStorageContract(TwoFromTheCasketDbContext context)
+    {
+        _dbContext = context;
+
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.CreateMap<Work_Supply, WorkSupplyDataModel>();
+            cfg.CreateMap<WorkSupplyDataModel, Work_Supply>();
+        });
+
+        _mapper = new Mapper(config);
+    }
+
+    public List<WorkSupplyDataModel> GetListBySupplyId(string supplyId)
+    {
+        try
+        {
+            var list = _dbContext.WorkSupplyies
+                .Where(x => x.SupplyId == supplyId)
+                .ToList();
+
+            return list.Select(x => _mapper.Map<WorkSupplyDataModel>(x)).ToList();
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public void AddElement(WorkSupplyDataModel workSupply)
+    {
+        try
+        {
+            var entity = _mapper.Map<Work_Supply>(workSupply);
+
+            _dbContext.WorkSupplyies.Add(entity);
+
+            var warehouseId = _dbContext.Supplies
+                .Where(s => s.Id == workSupply.SupplyId)
+                .Select(s => s.WarehouseId)
+                .FirstOrDefault();
+
+            if (warehouseId == null)
+                throw new ElementNotFoundException("SupplyId not linked to any Warehouse");
+
+            var warehouseWork = _dbContext.WorkWarehouses
+                .FirstOrDefault(x => x.WorkId == workSupply.WorkId && x.WarehouseId == warehouseId);
+
+            if (warehouseWork != null)
+            {
+                warehouseWork.Quantity += (decimal)workSupply.Quantity;
+            }
+            else
+            {
+                _dbContext.WorkWarehouses.Add(new Work_Warehouse
+                {
+                    WorkId = workSupply.WorkId,
+                    WarehouseId = warehouseId,
+                    Quantity = (decimal)workSupply.Quantity
+                });
+            }
+
+            _dbContext.SaveChanges();
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public void DelElement(string workId, string supplyId)
+    {
+        try
+        {
+            var entity = _dbContext.WorkSupplyies
+                .FirstOrDefault(x => x.WorkId == workId && x.SupplyId == supplyId)
+                ?? throw new ElementNotFoundException($"Work_Supply: WorkId={workId}, SupplyId={supplyId}");
+
+            var supply = _dbContext.Supplies.FirstOrDefault(x => x.Id == supplyId)
+                         ?? throw new ElementNotFoundException(supplyId);
+
+            var warehouseWork = _dbContext.WorkWarehouses
+                .FirstOrDefault(x => x.WorkId == workId && x.WarehouseId == supply.WarehouseId);
+
+            if (warehouseWork != null)
+            {
+                warehouseWork.Quantity -= entity.Quantity;
+                if (warehouseWork.Quantity < 0)
+                    warehouseWork.Quantity = 0;
+            }
+
+            _dbContext.WorkSupplyies.Remove(entity);
+            _dbContext.SaveChanges();
+        }
+        catch (ElementNotFoundException)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+}

TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/WorkWarehouseStorageContract.cs

@@ -0,0 +1,138 @@
+using AutoMapper;
+using Microsoft.EntityFrameworkCore;
+using Npgsql;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketContracts.StorageContracts;
+using TwoFromTheCasketDatabase.Models;
+
+namespace TwoFromTheCasketDatabase.Implementations;
+
+public class WorkWarehouseStorageContract : IWorkWarehouseStorageContract
+{
+    private readonly TwoFromTheCasketDbContext _dbContext;
+    private readonly Mapper _mapper;
+
+    public WorkWarehouseStorageContract(TwoFromTheCasketDbContext context)
+    {
+        _dbContext = context;
+        var conf = new MapperConfiguration(cfg =>
+        {
+            cfg.CreateMap<WorkWarehouseDataModel, Work_Warehouse>();
+            cfg.CreateMap<Work_Warehouse, WorkWarehouseDataModel>();
+        });
+        _mapper = new Mapper(conf);
+    }
+
+    public List<WorkWarehouseDataModel> GetListByWorkId(string workId)
+    {
+        try
+        {
+            return [.. _dbContext.WorkWarehouses
+                        .Where(x => x.WorkId == workId)
+                        .Select(x => _mapper.Map<WorkWarehouseDataModel>(x))];
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public List<WorkWarehouseDataModel> GetListByWarehouseId(string warehouseId)
+    {
+        try
+        {
+            return [.. _dbContext.WorkWarehouses
+                        .Where(x => x.WarehouseId == warehouseId)
+                        .Select(x => _mapper.Map<WorkWarehouseDataModel>(x))];
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public WorkWarehouseDataModel? GetElementByWorkAndWarehouse(string workId, string warehouseId)
+    {
+        try
+        {
+            var workWarehouse = _dbContext.WorkWarehouses
+                .FirstOrDefault(x => x.WorkId == workId && x.WarehouseId == warehouseId);
+
+            return _mapper.Map<WorkWarehouseDataModel>(workWarehouse);
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public void AddElement(WorkWarehouseDataModel workWarehouseDataModel)
+    {
+        try
+        {
+            _dbContext.WorkWarehouses.Add(_mapper.Map<Work_Warehouse>(workWarehouseDataModel));
+            _dbContext.SaveChanges();
+        }
+        catch (DbUpdateException ex) when (ex.InnerException is PostgresException { ConstraintName: "PK_Work_Warehouse" })
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new ElementExistsException("WorkWarehouse", $"{workWarehouseDataModel.WorkId}, {workWarehouseDataModel.WarehouseId}");
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public void UpdElement(WorkWarehouseDataModel workWarehouseDataModel)
+    {
+        try
+        {
+            var element = _dbContext.WorkWarehouses.FirstOrDefault(x => x.WorkId == workWarehouseDataModel.WorkId &&
+                                                                         x.WarehouseId == workWarehouseDataModel.WarehouseId)
+                ?? throw new ElementNotFoundException($"{workWarehouseDataModel.WorkId}, {workWarehouseDataModel.WarehouseId}");
+
+            element.Quantity = (decimal)workWarehouseDataModel.Quantity;
+
+            _dbContext.WorkWarehouses.Update(element);
+            _dbContext.SaveChanges();
+        }
+        catch (ElementNotFoundException)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+
+    public void DelElement(string workId, string warehouseId)
+    {
+        try
+        {
+            var element = _dbContext.WorkWarehouses.FirstOrDefault(x => x.WorkId == workId && x.WarehouseId == warehouseId)
+                ?? throw new ElementNotFoundException($"{workId}, {warehouseId}");
+
+            _dbContext.WorkWarehouses.Remove(element);
+            _dbContext.SaveChanges();
+        }
+        catch (ElementNotFoundException)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw;
+        }
+        catch (Exception ex)
+        {
+            _dbContext.ChangeTracker.Clear();
+            throw new StorageException(ex);
+        }
+    }
+}

TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Implementations/WorkerComplitedWorkStorageContract.cs

@@ -1,124 +0,0 @@
-using AutoMapper;
-using Microsoft.EntityFrameworkCore;
-using TwoFromTheCasketContracts.DataModels;
-using TwoFromTheCasketContracts.Exceptions;
-using TwoFromTheCasketContracts.StorageContracts;
-using TwoFromTheCasketDatabase.Models;
-
-namespace TwoFromTheCasketDatabase.Implementations;
-
-public class WorkerComplitedWorkStorageContract : IWorkerComplitedWorkStorageContract
-{
-    private readonly TwoFromTheCasketDbContext _dbContext;
-    private readonly Mapper _mapper;
-
-    public WorkerComplitedWorkStorageContract(TwoFromTheCasketDbContext context)
-    {
-        _dbContext = context;
-        var conf = new MapperConfiguration(cfg =>
-        {
-            cfg.CreateMap<WorkerComplitedWork, WorkerComplitedWorkDataModel>();
-            cfg.CreateMap<WorkerComplitedWorkDataModel, WorkerComplitedWork>();
-        });
-        _mapper = new Mapper(conf);
-    }
-
-    public List<WorkerComplitedWorkDataModel> GetList(string? workerId = null, string? complitedWorkId = null)
-    {
-        try
-        {
-            var query = _dbContext.WorkerComplitedWorks.AsQueryable();
-
-            if (!string.IsNullOrEmpty(workerId))
-                query = query.Where(x => x.WorkerId == workerId);
-
-            if (!string.IsNullOrEmpty(complitedWorkId))
-                query = query.Where(x => x.ComplitedWorkId == complitedWorkId);
-
-            return [.. query.Select(x => _mapper.Map<WorkerComplitedWorkDataModel>(x))];
-        }
-        catch (Exception ex)
-        {
-            _dbContext.ChangeTracker.Clear();
-            throw new StorageException(ex);
-        }
-    }
-
-    public WorkerComplitedWorkDataModel? GetElementById(string id)
-    {
-        try
-        {
-            var element = _dbContext.WorkerComplitedWorks.FirstOrDefault(x => x.ComplitedWorkId == id);
-            return element != null ? _mapper.Map<WorkerComplitedWorkDataModel>(element) : null;
-        }
-        catch (Exception ex)
-        {
-            _dbContext.ChangeTracker.Clear();
-            throw new StorageException(ex);
-        }
-    }
-
-    public void AddElement(WorkerComplitedWorkDataModel workerComplitedWorkDataModel)
-    {
-        try
-        {
-            _dbContext.WorkerComplitedWorks.Add(_mapper.Map<WorkerComplitedWork>(workerComplitedWorkDataModel));
-            _dbContext.SaveChanges();
-        }
-        catch (DbUpdateException ex)
-        {
-            _dbContext.ChangeTracker.Clear();
-            throw new StorageException(ex);
-        }
-        catch (Exception ex)
-        {
-            _dbContext.ChangeTracker.Clear();
-            throw new StorageException(ex);
-        }
-    }
-
-    public void UpdElement(WorkerComplitedWorkDataModel workerComplitedWorkDataModel)
-    {
-        try
-        {
-            var existing = _dbContext.WorkerComplitedWorks.FirstOrDefault(x =>
-                x.WorkerId == workerComplitedWorkDataModel.WorkerId && x.ComplitedWorkId == workerComplitedWorkDataModel.ComplitedWorkId)
-                ?? throw new ElementNotFoundException($"{workerComplitedWorkDataModel.WorkerId}-{workerComplitedWorkDataModel.ComplitedWorkId}");
-
-            existing.NumberOfWorkingHours = workerComplitedWorkDataModel.NumberOfWorkingHours;
-            _dbContext.SaveChanges();
-        }
-        catch (ElementNotFoundException)
-        {
-            _dbContext.ChangeTracker.Clear();
-            throw;
-        }
-        catch (Exception ex)
-        {
-            _dbContext.ChangeTracker.Clear();
-            throw new StorageException(ex);
-        }
-    }
-
-    public void DelElement(string id)
-    {
-        try
-        {
-            var element = _dbContext.WorkerComplitedWorks.FirstOrDefault(x => x.ComplitedWorkId == id)
-                ?? throw new ElementNotFoundException(id);
-
-            _dbContext.WorkerComplitedWorks.Remove(element);
-            _dbContext.SaveChanges();
-        }
-        catch (ElementNotFoundException)
-        {
-            _dbContext.ChangeTracker.Clear();
-            throw;
-        }
-        catch (Exception ex)
-        {
-            _dbContext.ChangeTracker.Clear();
-            throw new StorageException(ex);
-        }
-    }
-}

TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Models/Supply.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TwoFromTheCasketDatabase.Models;
+
+public class Supply
+{
+    public required string Id { get; set; }
+    public required string WarehouseId { get; set; }
+    public DateTime SupplyDate { get; set; }
+
+    public Warehouse? Warehouse { get; set; }
+    public List<Work_Supply>? Works { get; set; }
+}

TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Models/Warehouse.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TwoFromTheCasketDatabase.Models;
+
+public class Warehouse
+{
+    public required string Id { get; set; }
+    public required string Name { get; set; }
+    public required string Location { get; set; }
+
+    public List<Supply>? Supplies { get; set; }
+    public List<Work_Warehouse>? WorkWarehouses { get; set; }
+}

TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Models/Work.cs

@@ -21,4 +21,8 @@ public class Work
     public DateTime Date { get; set; }
 
     public List<ComplitedWork>? ComplitedWorks { get; set; }
+
+    public List<Work_Supply>? WorkSupplies { get; set; }
+
+    public List<Work_Warehouse>? WorkWarehouses { get; set; }
 }

TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Models/Work_Supply.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TwoFromTheCasketDatabase.Models;
+
+public class Work_Supply
+{
+    public required string WorkId { get; set; }
+    public required string SupplyId { get; set; }
+    public decimal Quantity { get; set; }
+
+    public Work? Work { get; set; }
+    public Supply? Supply { get; set; }
+}

TwoFromTheCasketContracts/TwoFromTheCasketDatabase/Models/Work_Warehouse.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace TwoFromTheCasketDatabase.Models;
+
+public class Work_Warehouse
+{
+    public required string WorkId { get; set; }
+    public required string WarehouseId { get; set; }
+    public decimal Quantity { get; set; }
+
+    public Work? Work { get; set; }
+    public Warehouse? Warehouse { get; set; }
+}

TwoFromTheCasketContracts/TwoFromTheCasketDatabase/TwoFromTheCasketDbContext.cs

@@ -77,6 +77,42 @@ public class TwoFromTheCasketDbContext : DbContext
                 x => SerializeSalaryConfiguration(x),
                 x => DeserializeSalaryConfiguration(x)
             );
+
+        modelBuilder.Entity<Work_Supply>()
+        .HasKey(ws => new { ws.WorkId, ws.SupplyId });
+
+        modelBuilder.Entity<Work_Warehouse>()
+            .HasKey(ww => new { ww.WorkId, ww.WarehouseId });
+
+        modelBuilder.Entity<Warehouse>()
+            .HasMany(w => w.Supplies)
+            .WithOne(s => s.Warehouse)
+            .HasForeignKey(s => s.WarehouseId);
+
+        modelBuilder.Entity<Warehouse>()
+            .HasMany(w => w.WorkWarehouses)
+            .WithOne(ww => ww.Warehouse)
+            .HasForeignKey(ww => ww.WarehouseId);
+
+        modelBuilder.Entity<Supply>()
+            .HasMany(s => s.Works)
+            .WithOne(ws => ws.Supply)
+            .HasForeignKey(ws => ws.SupplyId);
+
+        modelBuilder.Entity<Work>()
+            .HasMany(w => w.ComplitedWorks)
+            .WithOne(cw => cw.Work)
+            .HasForeignKey(cw => cw.WorkId);
+
+        modelBuilder.Entity<Work>()
+            .HasMany(w => w.WorkSupplies)
+            .WithOne(ws => ws.Work)
+            .HasForeignKey(ws => ws.WorkId);
+
+        modelBuilder.Entity<Work>()
+            .HasMany(w => w.WorkWarehouses)
+            .WithOne(ww => ww.Work)
+            .HasForeignKey(ww => ww.WorkId);
     }
 
     protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
@@ -93,6 +129,10 @@ public class TwoFromTheCasketDbContext : DbContext
     public DbSet<Work> Works { get; set; }
     public DbSet<Worker> Workers { get; set; }
     public DbSet<WorkerComplitedWork> WorkerComplitedWorks { get; set; }
+    public DbSet<Warehouse> Warehouses { get; set; }
+    public DbSet<Work_Warehouse> WorkWarehouses { get; set; }
+    public DbSet<Work_Supply> WorkSupplyies { get; set; }
+    public DbSet<Supply> Supplies { get; set; }
 
     public static string SerializeSalaryConfiguration(SalaryConfiguration config) =>
             JsonConvert.SerializeObject(config);

TwoFromTheCasketContracts/TwoFromTheCasketTests/AdapterTest/WarehouseAdapterTests.cs

@@ -0,0 +1,426 @@
+using System.Net;
+using System.Net.NetworkInformation;
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using Moq;
+using NUnit.Framework;
+using TwoFromTheCasketContracts.BindingModels;
+using TwoFromTheCasketContracts.BusinessLogicsContracts;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketContracts.ViewModels;
+using TwoFromTheCasketWebApi.Adapters;
+
+namespace TwoFromTheCasketTests.AdapterTests;
+
+[TestFixture]
+public class WarehouseAdapterTests
+{
+    private WarehouseAdapter _adapter;
+    private Mock<IWarehouseBuisnessLogicContract> _logic;
+    private Mock<ILogger<WarehouseAdapter>> _logger;
+    private Mock<HttpRequest> _request;
+    private Mock<HttpResponse> _response;
+    private int _status;
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        _logic = new Mock<IWarehouseBuisnessLogicContract>();
+        _logger = new Mock<ILogger<WarehouseAdapter>>();
+        _adapter = new WarehouseAdapter(_logic.Object, _logger.Object);
+        _request = new Mock<HttpRequest>();
+    }
+
+    [SetUp]
+    public void SetUp()
+    {
+        _status = 0;
+        _response = CreateMockResponse();
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        _logic.Reset();
+        _request.Reset();
+        _response.Reset();
+    }
+
+    private Mock<HttpResponse> CreateMockResponse()
+    {
+        var mock = new Mock<HttpResponse>();
+        mock.Setup(x => x.StatusCode).Returns(_status);
+        mock.SetupSet(x => x.StatusCode = It.IsAny<int>())
+            .Callback<int>(code => _status = code);
+        return mock;
+    }
+
+    [Test]
+    public void GetList_ReturnsRecords()
+    {
+        var data = new List<WarehouseDataModel>
+        {
+            new("id1", "W1", "L1", []),
+            new("id2", "W2", "L2", [])
+        };
+        _logic.Setup(x => x.GetWarehousesByName(It.IsAny<string>())).Returns(data);
+
+        var r = _adapter.GetList().GetResponse(_request.Object, _response.Object) as ObjectResult;
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.OK));
+        var list = r?.Value as List<WarehouseViewModel>;
+        Assert.That(list?.Count, Is.EqualTo(data.Count));
+    }
+
+    [Test]
+    public void GetList_ReturnsEmpty()
+    {
+        _logic.Setup(x => x.GetWarehousesByName(It.IsAny<string>())).Returns([]);
+
+        var r = _adapter.GetList().GetResponse(_request.Object, _response.Object) as ObjectResult;
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.OK));
+        var list = r?.Value as List<WarehouseViewModel>;
+        Assert.That(list, Is.Empty);
+    }
+
+    [Test]
+    public void GetList_NullList()
+    {
+        _logic.Setup(x => x.GetWarehousesByName(It.IsAny<string>())).Throws<NullListException>();
+
+        var r = _adapter.GetList().GetResponse(_request.Object, _response.Object) as ObjectResult;
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.NotFound));
+    }
+
+    [Test]
+    public void GetList_StorageException()
+    {
+        _logic.Setup(x => x.GetWarehousesByName(It.IsAny<string>()))
+        .Throws(new StorageException(new System.Exception("err")));
+
+        var r = _adapter.GetList().GetResponse(_request.Object, _response.Object) as ObjectResult;
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.InternalServerError));
+    }
+
+    [Test]
+    public void GetList_GenericException()
+    {
+        _logic.Setup(x => x.GetWarehousesByName(It.IsAny<string>()))
+        .Throws(new System.Exception());
+
+        var r = _adapter.GetList().GetResponse(_request.Object, _response.Object) as ObjectResult;
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.InternalServerError));
+    }
+
+    [Test]
+    public void GetElement_ReturnsRecord()
+    {
+        var id = Guid.NewGuid().ToString();
+        var data = new WarehouseDataModel(id, "Name", "Loc", []);
+        _logic.Setup(l => l.GetWarehouseByData(id)).Returns(data);
+
+        var res = _adapter.GetElement(id).GetResponse(_request.Object, _response.Object) as ObjectResult;
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.OK));
+        var vm = res?.Value as WarehouseViewModel;
+        Assert.That(vm?.Id, Is.EqualTo(id));
+    }
+
+    [Test]
+    public void GetElement_ArgumentNullException()
+    {
+        _logic.Setup(l => l.GetWarehouseByData(It.IsAny<string>()))
+              .Throws<ArgumentNullException>();
+
+        _adapter.GetElement("").GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public void GetElement_ElementNotFoundException()
+    {
+        _logic.Setup(l => l.GetWarehouseByData(It.IsAny<string>()))
+              .Throws(new ElementNotFoundException("msg"));
+
+        _adapter.GetElement("id").GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.NotFound));
+    }
+
+    [Test]
+    public void GetElement_StorageException()
+    {
+        _logic.Setup(l => l.GetWarehouseByData(It.IsAny<string>()))
+              .Throws(new StorageException(new Exception("inner")));
+
+        _adapter.GetElement("id").GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.InternalServerError));
+    }
+
+    [Test]
+    public void GetElement_GenericException()
+    {
+        _logic.Setup(l => l.GetWarehouseByData(It.IsAny<string>()))
+              .Throws(new Exception());
+
+        _adapter.GetElement("id").GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.InternalServerError));
+    }
+
+    [Test]
+    public void Register_ValidRecord()
+    {
+        var bm = new WarehouseBindingModel { Id = Guid.NewGuid().ToString(), Name = "N", Location = "L" };
+        var flag = false;
+
+        _logic.Setup(l => l.InsertWarehouse(It.IsAny<WarehouseDataModel>()))
+              .Callback<WarehouseDataModel>(dm => flag = dm.Id == bm.Id && dm.Name == bm.Name && dm.Location == bm.Location);
+
+        var res = _adapter.Register(bm).GetResponse(_request.Object, _response.Object) as StatusCodeResult;
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(_status, Is.EqualTo((int)HttpStatusCode.NoContent));
+            Assert.That(flag, Is.True);
+            _logic.Verify(l => l.InsertWarehouse(It.IsAny<WarehouseDataModel>()), Times.Once);
+        });
+    }
+
+    [Test]
+    public void Register_ArgumentNullException()
+    {
+        _logic.Setup(l => l.InsertWarehouse(It.IsAny<WarehouseDataModel>()))
+              .Throws<ArgumentNullException>();
+
+        _adapter.Register(new WarehouseBindingModel())
+                .GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public void Register_ValidationException()
+    {
+        _logic.Setup(l => l.InsertWarehouse(It.IsAny<WarehouseDataModel>()))
+              .Throws(new ValidationException("bad"));
+
+        _adapter.Register(new WarehouseBindingModel())
+                .GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public void Register_ElementExistsException()
+    {
+        _logic.Setup(l => l.InsertWarehouse(It.IsAny<WarehouseDataModel>()))
+              .Throws(new ElementExistsException("exists", "Id"));
+
+        _adapter.Register(new WarehouseBindingModel())
+                .GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public void Register_StorageException()
+    {
+        _logic.Setup(l => l.InsertWarehouse(It.IsAny<WarehouseDataModel>()))
+              .Throws(new StorageException(new Exception("inner")));
+
+        _adapter.Register(new WarehouseBindingModel())
+                .GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.InternalServerError));
+    }
+
+    [Test]
+    public void Register_GenericException()
+    {
+        _logic.Setup(l => l.InsertWarehouse(It.IsAny<WarehouseDataModel>()))
+              .Throws(new Exception("oops"));
+
+        _adapter.Register(new WarehouseBindingModel())
+                .GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.InternalServerError));
+    }
+
+    [Test]
+    public void ChangeInfo_ValidRecord()
+    {
+        var bm = new WarehouseBindingModel { Id = Guid.NewGuid().ToString(), Name = "Upd", Location = "Loc" };
+        var flag = false;
+
+        _logic.Setup(l => l.UpdateWarehouse(It.IsAny<WarehouseDataModel>()))
+              .Callback<WarehouseDataModel>(dm => flag = dm.Id == bm.Id && dm.Name == bm.Name && dm.Location == bm.Location);
+
+        var res = _adapter.ChangeInfo(bm).GetResponse(_request.Object, _response.Object) as StatusCodeResult;
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(_status, Is.EqualTo((int)HttpStatusCode.NoContent));
+            Assert.That(flag, Is.True);
+            _logic.Verify(l => l.UpdateWarehouse(It.IsAny<WarehouseDataModel>()), Times.Once);
+        });
+    }
+
+    [Test]
+    public void ChangeInfo_ArgumentNullException()
+    {
+        _logic.Setup(l => l.UpdateWarehouse(It.IsAny<WarehouseDataModel>()))
+              .Throws<ArgumentNullException>();
+
+        _adapter.ChangeInfo(new WarehouseBindingModel())
+                .GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public void ChangeInfo_ValidationException()
+    {
+        _logic.Setup(l => l.UpdateWarehouse(It.IsAny<WarehouseDataModel>()))
+              .Throws(new ValidationException("bad"));
+
+        _adapter.ChangeInfo(new WarehouseBindingModel())
+                .GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public void ChangeInfo_ElementNotFoundException()
+    {
+        var id = Guid.NewGuid().ToString();
+        _logic.Setup(l => l.UpdateWarehouse(It.IsAny<WarehouseDataModel>()))
+              .Throws(new ElementNotFoundException(id));
+
+        var bm = new WarehouseBindingModel { Id = id };
+        _adapter.ChangeInfo(bm).GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.NotFound));
+    }
+
+    [Test]
+    public void ChangeInfo_ElementExistsException()
+    {
+        _logic.Setup(l => l.UpdateWarehouse(It.IsAny<WarehouseDataModel>()))
+              .Throws(new ElementExistsException("exists", "Id"));
+
+        _adapter.ChangeInfo(new WarehouseBindingModel())
+                .GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public void ChangeInfo_StorageException()
+    {
+        _logic.Setup(l => l.UpdateWarehouse(It.IsAny<WarehouseDataModel>()))
+              .Throws(new StorageException(new Exception("inner")));
+
+        _adapter.ChangeInfo(new WarehouseBindingModel())
+                .GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.InternalServerError));
+    }
+
+    [Test]
+    public void ChangeInfo_GenericException()
+    {
+        _logic.Setup(l => l.UpdateWarehouse(It.IsAny<WarehouseDataModel>()))
+              .Throws(new Exception("oops"));
+
+        _adapter.ChangeInfo(new WarehouseBindingModel())
+                .GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.InternalServerError));
+    }
+
+    [Test]
+    public void Remove_Valid()
+    {
+        var flag = false;
+        const string id = "good‑id";
+
+        _logic.Setup(l => l.DeleteWarehouse(It.IsAny<string>()))
+              .Callback<string>(x => flag = x == id);
+
+        var res = _adapter.Remove(id).GetResponse(_request.Object, _response.Object) as StatusCodeResult;
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(_status, Is.EqualTo((int)HttpStatusCode.NoContent));
+            Assert.That(flag, Is.True);
+            _logic.Verify(l => l.DeleteWarehouse(It.IsAny<string>()), Times.Once);
+        });
+    }
+
+    [Test]
+    public void Remove_ArgumentNullException()
+    {
+        _logic.Setup(l => l.DeleteWarehouse(It.IsAny<string>()))
+              .Throws<ArgumentNullException>();
+
+        _adapter.Remove("").GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public void Remove_ValidationException()
+    {
+        _logic.Setup(l => l.DeleteWarehouse(It.IsAny<string>()))
+              .Throws(new ValidationException("bad"));
+
+        _adapter.Remove("bad").GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public void Remove_ElementNotFoundException()
+    {
+        const string id = "missing";
+        _logic.Setup(l => l.DeleteWarehouse(It.IsAny<string>()))
+              .Throws(new ElementNotFoundException(id));
+
+        _adapter.Remove(id).GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.NotFound));
+    }
+
+    [Test]
+    public void Remove_StorageException()
+    {
+        _logic.Setup(l => l.DeleteWarehouse(It.IsAny<string>()))
+              .Throws(new StorageException(new Exception("inner")));
+
+        _adapter.Remove("id").GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.InternalServerError));
+    }
+
+    [Test]
+    public void Remove_GenericException()
+    {
+        _logic.Setup(l => l.DeleteWarehouse(It.IsAny<string>()))
+              .Throws(new Exception("oops"));
+
+        _adapter.Remove("id").GetResponse(_request.Object, _response.Object);
+
+        Assert.That(_status, Is.EqualTo((int)HttpStatusCode.InternalServerError));
+    }
+
+
+}

TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/ComplitedWorkBusinessLogicContractTests.cs

@@ -6,6 +6,7 @@ using System.Collections.Generic;
 using TwoFromTheCasketBusinessLogic.Implementation;
 using TwoFromTheCasketContracts.DataModels;
 using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketContracts.Infastructure.SalaryConfiguration;
 using TwoFromTheCasketContracts.StorageContracts;
 
 namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
@@ -14,19 +15,26 @@ namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
     internal class ComplitedWorkBusinessLogicContractTests
     {
         private ComplitedWorkBusinessLogicContract _complitedWorkBusinessLogicContract;
+        private WarehouseBusinessLogicContract _warehouseBusinessLogicContract;
+        private Mock<IWorkerStorageContract> _workerStorageMock;
         private Mock<IComplitedWorkStorageContract> _complitedWorkStorageMock;
+        private Mock<IWarehouseStorageContract> _warehouseStorageMock;
 
         [OneTimeSetUp]
         public void OneTimeSetUp()
         {
             _complitedWorkStorageMock = new Mock<IComplitedWorkStorageContract>();
-            _complitedWorkBusinessLogicContract = new ComplitedWorkBusinessLogicContract(_complitedWorkStorageMock.Object, new Mock<ILogger>().Object);
+            _warehouseStorageMock = new Mock<IWarehouseStorageContract>();
+            _workerStorageMock = new Mock<IWorkerStorageContract>();
+            _complitedWorkBusinessLogicContract = new ComplitedWorkBusinessLogicContract(_complitedWorkStorageMock.Object, _warehouseStorageMock.Object, new Mock<ILogger>().Object, _workerStorageMock.Object);
         }
 
-        [SetUp]
-        public void SetUp()
+        [TearDown]
+        public void TearDown()
         {
             _complitedWorkStorageMock.Reset();
+            _warehouseStorageMock.Reset();
+            _workerStorageMock.Reset();
         }
 
         [Test]
@@ -206,6 +214,69 @@ namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
             _complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, roomId, null, null), Times.Once);
         }
 
+        [Test]
+        public void CalculateProfitByPeriod_WithDifferentSalaryConfigs_ReturnsCorrectProfit_Test()
+        {
+            var fromDate = DateTime.UtcNow.Date;
+            var toDate = fromDate.AddDays(1);
+            var worker1Id = Guid.NewGuid().ToString();
+            var worker2Id = Guid.NewGuid().ToString();
+
+            var completedWorks = new List<ComplitedWorkDataModel>
+            {
+                new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(),
+                    new List<WorkerComplitedWorkDataModel>
+                    {
+                        new(worker1Id, Guid.NewGuid().ToString(), 5),
+                        new(worker2Id, Guid.NewGuid().ToString(), 3)
+                    })
+            };
+
+            var worker1 = new WorkerDataModel(
+                worker1Id,
+                "Иванов Иван",
+                "spec1",
+                "+79991234567",
+                DateTime.UtcNow.AddYears(-20),
+                new PieceworkSalaryConfiguration
+                {
+                    Rate = 1,
+                    UnitRate = 100,
+                    BonusPerUnit = 50
+                }
+            );
+            var worker2 = new WorkerDataModel(
+                worker2Id,
+                "Иванов Иван",
+                "spec2",
+                "+79991234667",
+                DateTime.UtcNow.AddYears(-20),
+                new OvertimeSalaryConfiguration
+                {
+                    Rate = 200,
+                    OvertimeMultiplier = 1.5
+                }
+            );
+
+            _complitedWorkStorageMock.Setup(x => x.GetList(fromDate, toDate, null, null, null))
+                .Returns(completedWorks);
+
+            _workerStorageMock.Setup(x => x.GetElementById(worker1Id)).Returns(worker1);
+            _workerStorageMock.Setup(x => x.GetElementById(worker2Id)).Returns(worker2);
+
+            _complitedWorkBusinessLogicContract = new ComplitedWorkBusinessLogicContract(
+                _complitedWorkStorageMock.Object,
+                _warehouseStorageMock.Object,
+                new Mock<ILogger>().Object,
+                _workerStorageMock.Object
+            );
+
+            var profit = _complitedWorkBusinessLogicContract.CalculateProfitByPeriod(fromDate, toDate);
+
+            var expectedProfit = (int)(5 * 100 + 50 + 3 * 200 * 1.5);
+            Assert.That(profit, Is.EqualTo(expectedProfit));
+        }
+
         [Test]
         public void GetComplitedWorksByWorkTypeByPeriod_ReturnListOfRecords_Test()
         {
@@ -443,6 +514,7 @@ namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
         {
             var flag = false;
             var record = new ComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>());
+            _warehouseStorageMock.Setup(x => x.CheckWorks(It.IsAny<ComplitedWorkDataModel>())).Returns(true);
 
             _complitedWorkStorageMock.Setup(x => x.AddElement(It.IsAny<ComplitedWorkDataModel>()))
                 .Callback((ComplitedWorkDataModel x) =>
@@ -461,6 +533,7 @@ namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
         {
             _complitedWorkStorageMock.Setup(x => x.AddElement(It.IsAny<ComplitedWorkDataModel>()))
                 .Throws(new ElementExistsException("Data", "Data"));
+            _warehouseStorageMock.Setup(x => x.CheckWorks(It.IsAny<ComplitedWorkDataModel>())).Returns(true);
 
             Assert.That(() => _complitedWorkBusinessLogicContract.InsertComplitedWork(new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>())),
                 Throws.TypeOf<ElementExistsException>());
@@ -483,6 +556,7 @@ namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
         {
             _complitedWorkStorageMock.Setup(x => x.AddElement(It.IsAny<ComplitedWorkDataModel>()))
                 .Throws(new StorageException(new InvalidOperationException()));
+            _warehouseStorageMock.Setup(x => x.CheckWorks(It.IsAny<ComplitedWorkDataModel>())).Returns(true);
 
             Assert.That(() => _complitedWorkBusinessLogicContract.InsertComplitedWork(
                 new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>())),
@@ -491,6 +565,18 @@ namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
             _complitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<ComplitedWorkDataModel>()), Times.Once);
         }
 
+        [Test]
+        public void InsertComplitedWork_NotEnoughWorks_ThrowException_Test()
+        {
+            _warehouseStorageMock.Setup(x => x.CheckWorks(It.IsAny<ComplitedWorkDataModel>())).Returns(false);
+
+            Assert.That(() => _complitedWorkBusinessLogicContract.InsertComplitedWork(
+                new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), new List<WorkerComplitedWorkDataModel>())),
+                Throws.TypeOf<ValidationException>());
+
+            _warehouseStorageMock.Verify(x => x.CheckWorks(It.IsAny<ComplitedWorkDataModel>()), Times.Once);
+        }
+
         [Test]
         public void DeleteComplitedWork_CorrectRecord_Test()
         {

TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/RoomBusinessLogicContractTests.cs

@@ -18,13 +18,20 @@ namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
         private RoomBusinessLogicContract _roomBusinessLogic;
         private Mock<IRoomStorageContract> _roomStorageMock;
 
-        [SetUp]
-        public void Setup()
+
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
         {
             _roomStorageMock = new Mock<IRoomStorageContract>();
             _roomBusinessLogic = new RoomBusinessLogicContract(_roomStorageMock.Object, new Mock<ILogger>().Object);
         }
 
+        [TearDown]
+        public void TearDown()
+        {
+            _roomStorageMock.Reset();
+        }
+
         [Test]
         public void GetAllRooms_ReturnsListOfRooms()
         {
@@ -271,6 +278,85 @@ namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
             _roomStorageMock.Verify(x => x.GetListByAddress(address), Times.Once);
         }
 
+        [Test]
+        public void GetRoomHistory_ReturnsListOfRecords_Test()
+        {
+            var roomId = Guid.NewGuid().ToString();
+            var listOriginal = new List<RoomHistoryDataModel>
+        {
+            new(roomId, Guid.NewGuid().ToString(), TwoFromTheCasketContracts.Enums.TypeRoom.Office, DateTime.UtcNow.AddMonths(-2)),
+            new(roomId, Guid.NewGuid().ToString(), TwoFromTheCasketContracts.Enums.TypeRoom.PublicBuilding, DateTime.UtcNow.AddMonths(-1))
+        };
+
+            _roomStorageMock.Setup(x => x.GetHistoryRoomId(roomId)).Returns(listOriginal);
+
+            var result = _roomBusinessLogic.GetRoomHistory(roomId);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(result, Is.Not.Null);
+                Assert.That(result, Is.EquivalentTo(listOriginal));
+            });
+
+            _roomStorageMock.Verify(x => x.GetHistoryRoomId(roomId), Times.Once);
+        }
+
+        [Test]
+        public void GetRoomHistory_ReturnsEmptyList_Test()
+        {
+            var roomId = Guid.NewGuid().ToString();
+            _roomStorageMock.Setup(x => x.GetHistoryRoomId(roomId)).Returns(new List<RoomHistoryDataModel>());
+
+            var result = _roomBusinessLogic.GetRoomHistory(roomId);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(result, Is.Not.Null);
+                Assert.That(result.Count, Is.EqualTo(0));
+            });
+
+            _roomStorageMock.Verify(x => x.GetHistoryRoomId(roomId), Times.Once);
+        }
+
+        [Test]
+        public void GetRoomHistory_NullOrEmptyRoomId_ThrowsException_Test()
+        {
+            Assert.That(() => _roomBusinessLogic.GetRoomHistory(null), Throws.TypeOf<ArgumentNullException>());
+            Assert.That(() => _roomBusinessLogic.GetRoomHistory(string.Empty), Throws.TypeOf<ArgumentNullException>());
+
+            _roomStorageMock.Verify(x => x.GetHistoryRoomId(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void GetRoomHistory_RoomIdIsNotGuid_ThrowsException_Test()
+        {
+            Assert.That(() => _roomBusinessLogic.GetRoomHistory("InvalidRoomId"), Throws.TypeOf<ValidationException>());
+
+            _roomStorageMock.Verify(x => x.GetHistoryRoomId(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void GetRoomHistory_ReturnsNull_ThrowsException_Test()
+        {
+            var roomId = Guid.NewGuid().ToString();
+            _roomStorageMock.Setup(x => x.GetHistoryRoomId(roomId)).Returns(() => null);
+
+            Assert.That(() => _roomBusinessLogic.GetRoomHistory(roomId), Throws.TypeOf<NullListException>());
+
+            _roomStorageMock.Verify(x => x.GetHistoryRoomId(roomId), Times.Once);
+        }
+
+        [Test]
+        public void GetRoomHistory_StorageThrowsException_Test()
+        {
+            var roomId = Guid.NewGuid().ToString();
+            _roomStorageMock.Setup(x => x.GetHistoryRoomId(roomId)).Throws(new StorageException(new InvalidOperationException()));
+
+            Assert.That(() => _roomBusinessLogic.GetRoomHistory(roomId), Throws.TypeOf<StorageException>());
+
+            _roomStorageMock.Verify(x => x.GetHistoryRoomId(roomId), Times.Once);
+        }
+
         [Test]
         public void GetRoomByData_GetById_ReturnsRoom()
         {

TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/RoomHistoryBusinessLogicContractTests.cs

@@ -1,289 +0,0 @@
-using Moq;
-using NUnit.Framework;
-using System;
-using System.Collections.Generic;
-using TwoFromTheCasketContracts.BusinessLogicsContracts;
-using TwoFromTheCasketContracts.DataModels;
-using TwoFromTheCasketContracts.StorageContracts;
-using TwoFromTheCasketContracts.Exceptions;
-using TwoFromTheCasketBusinessLogic.Implementation;
-using TwoFromTheCasketContracts.Enums;
-using Microsoft.Extensions.Logging;
-
-namespace TwoFromTheCasketTests.BusinessLogicsContractsTests;
-
-[TestFixture]
-public class RoomHistoryBusinessLogicContractTests
-{
-    private RoomHistoryBusinessLogicContract _roomHistoryBusinessLogic;
-    private Mock<IRoomHistoryStorageContract> _roomHistoryStorageMock;
-
-    [OneTimeSetUp]
-    public void OneTimeSetUp()
-    {
-        _roomHistoryStorageMock = new Mock<IRoomHistoryStorageContract>();
-        _roomHistoryBusinessLogic = new RoomHistoryBusinessLogicContract(_roomHistoryStorageMock.Object, new Mock<ILogger>().Object);
-    }
-
-    [SetUp]
-    public void SetUp()
-    {
-        _roomHistoryStorageMock.Reset();
-    }
-
-    [Test]
-    public void GetRoomHistory_ReturnsListOfRecords_Test()
-    {
-        var roomId = Guid.NewGuid().ToString();
-        var listOriginal = new List<RoomHistoryDataModel>
-        {
-            new(roomId, Guid.NewGuid().ToString(), TwoFromTheCasketContracts.Enums.TypeRoom.Office, DateTime.UtcNow.AddMonths(-2)),
-            new(roomId, Guid.NewGuid().ToString(), TwoFromTheCasketContracts.Enums.TypeRoom.PublicBuilding, DateTime.UtcNow.AddMonths(-1))
-        };
-
-        _roomHistoryStorageMock.Setup(x => x.GetList(roomId)).Returns(listOriginal);
-
-        var result = _roomHistoryBusinessLogic.GetRoomHistory(roomId);
-
-        Assert.Multiple(() =>
-        {
-            Assert.That(result, Is.Not.Null);
-            Assert.That(result, Is.EquivalentTo(listOriginal));
-        });
-
-        _roomHistoryStorageMock.Verify(x => x.GetList(roomId), Times.Once);
-    }
-
-    [Test]
-    public void GetRoomHistory_ReturnsEmptyList_Test()
-    {
-        var roomId = Guid.NewGuid().ToString();
-        _roomHistoryStorageMock.Setup(x => x.GetList(roomId)).Returns(new List<RoomHistoryDataModel>());
-
-        var result = _roomHistoryBusinessLogic.GetRoomHistory(roomId);
-
-        Assert.Multiple(() =>
-        {
-            Assert.That(result, Is.Not.Null);
-            Assert.That(result.Count, Is.EqualTo(0));
-        });
-
-        _roomHistoryStorageMock.Verify(x => x.GetList(roomId), Times.Once);
-    }
-
-    [Test]
-    public void GetRoomHistory_NullOrEmptyRoomId_ThrowsException_Test()
-    {
-        Assert.That(() => _roomHistoryBusinessLogic.GetRoomHistory(null), Throws.TypeOf<ArgumentNullException>());
-        Assert.That(() => _roomHistoryBusinessLogic.GetRoomHistory(string.Empty), Throws.TypeOf<ArgumentNullException>());
-
-        _roomHistoryStorageMock.Verify(x => x.GetList(It.IsAny<string>()), Times.Never);
-    }
-
-    [Test]
-    public void GetRoomHistory_RoomIdIsNotGuid_ThrowsException_Test()
-    {
-        Assert.That(() => _roomHistoryBusinessLogic.GetRoomHistory("InvalidRoomId"), Throws.TypeOf<ValidationException>());
-
-        _roomHistoryStorageMock.Verify(x => x.GetList(It.IsAny<string>()), Times.Never);
-    }
-
-    [Test]
-    public void GetRoomHistory_ReturnsNull_ThrowsException_Test()
-    {
-        var roomId = Guid.NewGuid().ToString();
-        _roomHistoryStorageMock.Setup(x => x.GetList(roomId)).Returns(() => null);
-
-        Assert.That(() => _roomHistoryBusinessLogic.GetRoomHistory(roomId), Throws.TypeOf<NullListException>());
-
-        _roomHistoryStorageMock.Verify(x => x.GetList(roomId), Times.Once);
-    }
-
-    [Test]
-    public void GetRoomHistory_StorageThrowsException_Test()
-    {
-        var roomId = Guid.NewGuid().ToString();
-        _roomHistoryStorageMock.Setup(x => x.GetList(roomId)).Throws(new StorageException(new InvalidOperationException()));
-
-        Assert.That(() => _roomHistoryBusinessLogic.GetRoomHistory(roomId), Throws.TypeOf<StorageException>());
-
-        _roomHistoryStorageMock.Verify(x => x.GetList(roomId), Times.Once);
-    }
-
-    [Test]
-    public async Task GetRoomHistoryAsync_ReturnsListOfRecords_Test()
-    {
-        var roomId = Guid.NewGuid().ToString();
-        var listOriginal = new List<RoomHistoryDataModel>
-        {
-            new(roomId, Guid.NewGuid().ToString(), TwoFromTheCasketContracts.Enums.TypeRoom.Office, DateTime.UtcNow.AddMonths(-2)),
-            new(roomId, Guid.NewGuid().ToString(), TwoFromTheCasketContracts.Enums.TypeRoom.PublicBuilding, DateTime.UtcNow.AddMonths(-1))
-        };
-
-        _roomHistoryStorageMock.Setup(x => x.GetListAsync(It.IsAny<CancellationToken>())).ReturnsAsync(listOriginal);
-
-        var result = await _roomHistoryStorageMock.Object.GetListAsync(CancellationToken.None);
-
-        Assert.Multiple(() =>
-        {
-            Assert.That(result, Is.Not.Null);
-            Assert.That(result, Is.EquivalentTo(listOriginal));
-        });
-
-        _roomHistoryStorageMock.Verify(x => x.GetListAsync(It.IsAny<CancellationToken>()), Times.Once);
-    }
-
-    [Test]
-    public async Task GetRoomHistoryAsync_ReturnsEmptyList_Test()
-    {
-        var roomId = Guid.NewGuid().ToString();
-
-        _roomHistoryStorageMock.Setup(x => x.GetListAsync(It.IsAny<CancellationToken>()))
-            .ReturnsAsync(new List<RoomHistoryDataModel>());
-
-        var result = await _roomHistoryStorageMock.Object.GetListAsync(CancellationToken.None);
-
-        Assert.Multiple(() =>
-        {
-            Assert.That(result, Is.Not.Null);
-            Assert.That(result.Count, Is.EqualTo(0));
-        });
-
-        _roomHistoryStorageMock.Verify(x => x.GetListAsync(It.IsAny<CancellationToken>()), Times.Once);
-    }
-
-    [Test]
-    public void GetLatestRoomHistory_ReturnsLatestRecord_Test()
-    {
-        var roomId = Guid.NewGuid().ToString();
-        var latestHistory = new RoomHistoryDataModel(roomId, Guid.NewGuid().ToString(), TwoFromTheCasketContracts.Enums.TypeRoom.PublicBuilding, DateTime.UtcNow);
-        var historyList = new List<RoomHistoryDataModel>
-        {
-            new(roomId, Guid.NewGuid().ToString(), TwoFromTheCasketContracts.Enums.TypeRoom.Office, DateTime.UtcNow.AddMonths(-2)),
-            new(roomId, Guid.NewGuid().ToString(), TwoFromTheCasketContracts.Enums.TypeRoom.Residential, DateTime.UtcNow.AddMonths(-1)),
-            latestHistory
-        };
-
-        _roomHistoryStorageMock.Setup(x => x.GetList(roomId)).Returns(historyList);
-
-        var result = _roomHistoryBusinessLogic.GetLatestRoomHistory(roomId);
-
-        Assert.Multiple(() =>
-        {
-            Assert.That(result, Is.Not.Null);
-            Assert.That(result, Is.EqualTo(latestHistory));
-        });
-
-        _roomHistoryStorageMock.Verify(x => x.GetList(roomId), Times.Once);
-    }
-
-    [Test]
-    public void GetLatestRoomHistory_EmptyHistoryList_ThrowsException_Test()
-    {
-        var roomId = Guid.NewGuid().ToString();
-        _roomHistoryStorageMock.Setup(x => x.GetList(roomId)).Returns(new List<RoomHistoryDataModel>());
-
-        Assert.That(() => _roomHistoryBusinessLogic.GetLatestRoomHistory(roomId), Throws.TypeOf<NullListException>());
-
-        _roomHistoryStorageMock.Verify(x => x.GetList(roomId), Times.Once);
-    }
-
-    [Test]
-    public void GetLatestRoomHistory_NullHistoryList_ThrowsException_Test()
-    {
-        var roomId = Guid.NewGuid().ToString();
-        _roomHistoryStorageMock.Setup(x => x.GetList(roomId)).Returns(() => null);
-
-        Assert.That(() => _roomHistoryBusinessLogic.GetLatestRoomHistory(roomId), Throws.TypeOf<NullListException>());
-
-        _roomHistoryStorageMock.Verify(x => x.GetList(roomId), Times.Once);
-    }
-
-    [Test]
-    public void GetLatestRoomHistory_NullOrEmptyRoomId_ThrowsException_Test()
-    {
-        Assert.That(() => _roomHistoryBusinessLogic.GetLatestRoomHistory(null), Throws.TypeOf<ArgumentNullException>());
-        Assert.That(() => _roomHistoryBusinessLogic.GetLatestRoomHistory(string.Empty), Throws.TypeOf<ArgumentNullException>());
-
-        _roomHistoryStorageMock.Verify(x => x.GetList(It.IsAny<string>()), Times.Never);
-    }
-
-    [Test]
-    public void GetLatestRoomHistory_RoomIdIsNotGuid_ThrowsException_Test()
-    {
-        Assert.That(() => _roomHistoryBusinessLogic.GetLatestRoomHistory("InvalidRoomId"), Throws.TypeOf<ValidationException>());
-
-        _roomHistoryStorageMock.Verify(x => x.GetList(It.IsAny<string>()), Times.Never);
-    }
-
-    [Test]
-    public void GetLatestRoomHistory_StorageThrowsException_Test()
-    {
-        var roomId = Guid.NewGuid().ToString();
-        _roomHistoryStorageMock.Setup(x => x.GetList(roomId)).Throws(new StorageException(new InvalidOperationException()));
-
-        Assert.That(() => _roomHistoryBusinessLogic.GetLatestRoomHistory(roomId), Throws.TypeOf<StorageException>());
-
-        _roomHistoryStorageMock.Verify(x => x.GetList(roomId), Times.Once);
-    }
-
-    [Test]
-    public void AddRoomHistory_CorrectRecord_Test()
-    {
-        var flag = false;
-        var roomHistory = new RoomHistoryDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), TypeRoom.Residential, DateTime.UtcNow);
-        _roomHistoryStorageMock.Setup(x => x.AddElement(It.IsAny<RoomHistoryDataModel>()))
-            .Callback((RoomHistoryDataModel x) =>
-            {
-                flag = x.RoomId == roomHistory.RoomId && x.OwnerFIO == roomHistory.OwnerFIO &&
-                       x.Type == roomHistory.Type && x.DateChange == roomHistory.DateChange;
-            });
-
-        _roomHistoryBusinessLogic.AddRoomHistory(roomHistory);
-
-        _roomHistoryStorageMock.Verify(x => x.AddElement(It.IsAny<RoomHistoryDataModel>()), Times.Once);
-        Assert.That(flag);
-    }
-
-    [Test]
-    public void AddRoomHistory_RecordWithExistingData_ThrowsException_Test()
-    {
-        var roomHistory = new RoomHistoryDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), TypeRoom.Office, DateTime.UtcNow);
-        _roomHistoryStorageMock.Setup(x => x.AddElement(It.IsAny<RoomHistoryDataModel>()))
-            .Throws(new ElementExistsException("RoomHistory", "Id"));
-
-        Assert.That(() => _roomHistoryBusinessLogic.AddRoomHistory(roomHistory), Throws.TypeOf<ElementExistsException>());
-
-        _roomHistoryStorageMock.Verify(x => x.AddElement(It.IsAny<RoomHistoryDataModel>()), Times.Once);
-    }
-
-    [Test]
-    public void AddRoomHistory_NullRecord_ThrowsException_Test()
-    {
-        Assert.That(() => _roomHistoryBusinessLogic.AddRoomHistory(null), Throws.TypeOf<ArgumentNullException>());
-
-        _roomHistoryStorageMock.Verify(x => x.AddElement(It.IsAny<RoomHistoryDataModel>()), Times.Never);
-    }
-
-    [Test]
-    public void AddRoomHistory_InvalidRecord_ThrowsException_Test()
-    {
-        var invalidRoomHistory = new RoomHistoryDataModel("", Guid.NewGuid().ToString(), TypeRoom.PublicBuilding, DateTime.UtcNow);
-
-        Assert.That(() => _roomHistoryBusinessLogic.AddRoomHistory(invalidRoomHistory), Throws.TypeOf<ValidationException>());
-
-        _roomHistoryStorageMock.Verify(x => x.AddElement(It.IsAny<RoomHistoryDataModel>()), Times.Never);
-    }
-
-    [Test]
-    public void AddRoomHistory_StorageThrowsException_Test()
-    {
-        var roomHistory = new RoomHistoryDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), TypeRoom.Office, DateTime.UtcNow);
-        _roomHistoryStorageMock.Setup(x => x.AddElement(It.IsAny<RoomHistoryDataModel>()))
-            .Throws(new StorageException(new InvalidOperationException()));
-
-        Assert.That(() => _roomHistoryBusinessLogic.AddRoomHistory(roomHistory), Throws.TypeOf<StorageException>());
-
-        _roomHistoryStorageMock.Verify(x => x.AddElement(It.IsAny<RoomHistoryDataModel>()), Times.Once);
-    }
-}

TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/SpecializationBusinessLogicContractTests.cs

@@ -19,13 +19,19 @@ public class SpecializationBusinessLogicContractTests
     private Mock<ISpecializationStorageContract> _specializationStorageMock;
     private ISpecializationBusinessLogicContract _specializationBusinessLogic;
 
-    [SetUp]
-    public void Setup()
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
     {
         _specializationStorageMock = new Mock<ISpecializationStorageContract>();
         _specializationBusinessLogic = new SpecializationBusinessLogicContract(_specializationStorageMock.Object, new Mock<ILogger>().Object);
     }
 
+    [TearDown]
+    public void TearDown()
+    {
+        _specializationStorageMock.Reset();
+    }
+
     [Test]
     public void GetAllSpecializations_ReturnListOfRecords_Test()
     {

TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/SupplyBusinessLogicContractTests.cs

@@ -0,0 +1,509 @@
+using Moq;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using TwoFromTheCasketContracts.BusinessLogicsContracts;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketBusinessLogic.Implementation;
+using TwoFromTheCasketContracts.Enums;
+using TwoFromTheCasketContracts.StorageContracts;
+using Microsoft.Extensions.Logging;
+
+
+namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
+{
+    [TestFixture]
+    public class SupplyBusinessLogicContractTests
+    {
+        private SupplyBusinessLogicContract _supplyBusinessLogic;
+        private Mock<ISupplyStorageContract> _supplyStorageMock;
+
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
+        {
+            _supplyStorageMock = new Mock<ISupplyStorageContract>();
+
+            _supplyBusinessLogic = new SupplyBusinessLogicContract(
+                _supplyStorageMock.Object,
+                new Mock<ILogger>().Object
+            );
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            _supplyStorageMock.Reset();
+        }
+
+        [Test]
+        public void GetSuppliesByPeriod_ReturnListOfRecords_Test()
+        {
+            // Arrange
+            var fromDate = DateTime.UtcNow.AddMonths(-1);
+            var toDate = DateTime.UtcNow;
+            var warehouseId = Guid.NewGuid().ToString();
+
+            var suppliesOriginal = new List<SupplyDataModel>
+            {
+                new SupplyDataModel(Guid.NewGuid().ToString(), warehouseId, fromDate.AddDays(5),
+                    new List<WorkSupplyDataModel>
+                    {
+                        new WorkSupplyDataModel(Guid.NewGuid().ToString(), warehouseId, 100)
+                    }),
+                new SupplyDataModel(Guid.NewGuid().ToString(), warehouseId, fromDate.AddDays(10),
+                    new List<WorkSupplyDataModel>
+                    {
+                        new WorkSupplyDataModel(Guid.NewGuid().ToString(), warehouseId, 200)
+                    })
+            };
+
+            _supplyStorageMock.Setup(x => x.GetList(fromDate, toDate, null)).Returns(suppliesOriginal);
+            
+            var supplies = _supplyBusinessLogic.GetSuppliesByPeriod(fromDate, toDate);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(supplies, Is.Not.Null);
+                Assert.That(supplies, Is.EquivalentTo(suppliesOriginal));
+            });
+
+            _supplyStorageMock.Verify(x => x.GetList(fromDate, toDate, null), Times.Once);
+        }
+
+
+        [Test]
+        public void GetSuppliesByPeriod_ReturnEmptyList_Test()
+        {
+            var fromDate = DateTime.UtcNow.AddMonths(-1);
+            var toDate = DateTime.UtcNow;
+
+            _supplyStorageMock
+                .Setup(x => x.GetList(fromDate, toDate, null))
+                .Returns(new List<SupplyDataModel>());
+
+            Assert.That(() => _supplyBusinessLogic.GetSuppliesByPeriod(fromDate, toDate), Throws.TypeOf<ElementNotFoundException>());
+
+            _supplyStorageMock.Verify(x => x.GetList(fromDate, toDate, null), Times.Once);
+        }
+
+
+
+        [Test]
+        public void GetSuppliesByPeriod_IncorrectDates_ThrowException_Test()
+        {
+            var date = DateTime.UtcNow;
+
+            Assert.That(() => _supplyBusinessLogic.GetSuppliesByPeriod(date, date), Throws.TypeOf<IncorrectDatesException>());
+            Assert.That(() => _supplyBusinessLogic.GetSuppliesByPeriod(date, date.AddSeconds(-1)), Throws.TypeOf<IncorrectDatesException>());
+
+            _supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Never);
+        }
+
+
+        [Test]
+        public void GetSuppliesByPeriod_ReturnNull_ThrowException_Test()
+        {
+            var fromDate = DateTime.UtcNow.AddMonths(-1);
+            var toDate = DateTime.UtcNow;
+
+            _supplyStorageMock.Setup(x => x.GetList(fromDate, toDate, null)).Returns((List<SupplyDataModel>)null);
+
+            Assert.That(() => _supplyBusinessLogic.GetSuppliesByPeriod(fromDate, toDate), Throws.TypeOf<NullListException>());
+
+            _supplyStorageMock.Verify(x => x.GetList(fromDate, toDate, null), Times.Once);
+        }
+
+
+        [Test]
+        public void GetSuppliesByPeriod_StorageThrowError_ThrowException_Test()
+        {
+            var fromDate = DateTime.UtcNow.AddMonths(-1);
+            var toDate = DateTime.UtcNow;
+
+            _supplyStorageMock.Setup(x => x.GetList(fromDate, toDate, null)).Throws(new StorageException(new InvalidOperationException()));
+
+            Assert.That(() => _supplyBusinessLogic.GetSuppliesByPeriod(fromDate, toDate), Throws.TypeOf<StorageException>());
+
+            _supplyStorageMock.Verify(x => x.GetList(fromDate, toDate, null), Times.Once);
+        }
+
+
+        [Test]
+        public void GetSuppliesByWarehouseId_ReturnListOfRecords_Test()
+        {
+            var warehouseId = Guid.NewGuid().ToString();
+            var fromDate = DateTime.UtcNow.AddMonths(-1);
+            var toDate = DateTime.UtcNow;
+
+            var suppliesOriginal = new List<SupplyDataModel>
+            {
+                new SupplyDataModel(Guid.NewGuid().ToString(), warehouseId, fromDate.AddDays(5),
+                    new List<WorkSupplyDataModel>
+                    {
+                        new WorkSupplyDataModel(Guid.NewGuid().ToString(), warehouseId, 100)
+                    }),
+                new SupplyDataModel(Guid.NewGuid().ToString(), warehouseId, fromDate.AddDays(10),
+                    new List<WorkSupplyDataModel>
+                    {
+                        new WorkSupplyDataModel(Guid.NewGuid().ToString(), warehouseId, 200)
+                    })
+            };
+
+            _supplyStorageMock.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), warehouseId)).Returns(suppliesOriginal);
+
+            var supplies = _supplyBusinessLogic.GetSuppliesByWarehouseId(warehouseId);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(supplies, Is.Not.Null);
+                Assert.That(supplies, Is.EquivalentTo(suppliesOriginal));
+            });
+
+            _supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), warehouseId), Times.Once);
+        }
+
+
+        [Test]
+        public void GetSuppliesByWarehouseId_ReturnEmptyList_Test()
+        {
+            var warehouseId = Guid.NewGuid().ToString();
+
+            _supplyStorageMock
+                .Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), warehouseId))
+                .Returns(new List<SupplyDataModel>());
+
+            Assert.That(() => _supplyBusinessLogic.GetSuppliesByWarehouseId(warehouseId), Throws.TypeOf<ElementNotFoundException>());
+
+            _supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), warehouseId), Times.Once);
+        }
+
+
+
+        [Test]
+        public void GetSuppliesByWarehouseId_WarehouseIdIsNullOrEmpty_ThrowException_Test()
+        {
+            var warehouseId = string.Empty;
+
+            Assert.That(() => _supplyBusinessLogic.GetSuppliesByWarehouseId(null), Throws.TypeOf<ArgumentNullException>());
+            Assert.That(() => _supplyBusinessLogic.GetSuppliesByWarehouseId(warehouseId), Throws.TypeOf<ArgumentNullException>());
+
+            _supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Never);
+        }
+
+
+        [Test]
+        public void GetSuppliesByWarehouseId_WarehouseIdIsNotGuid_ThrowException_Test()
+        {
+            var warehouseId = "invalid-guid";
+
+            Assert.That(() => _supplyBusinessLogic.GetSuppliesByWarehouseId(warehouseId), Throws.TypeOf<ValidationException>());
+
+            _supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Never);
+        }
+
+
+        [Test]
+        public void GetSuppliesByWarehouseId_ReturnNull_ThrowException_Test()
+        {
+            var warehouseId = Guid.NewGuid().ToString();
+
+            _supplyStorageMock.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), warehouseId)).Returns((List<SupplyDataModel>)null);
+
+            Assert.That(() => _supplyBusinessLogic.GetSuppliesByWarehouseId(warehouseId), Throws.TypeOf<NullListException>());
+
+            _supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), warehouseId), Times.Once);
+        }
+
+
+        [Test]
+        public void GetSuppliesByWarehouseId_StorageThrowError_ThrowException_Test()
+        {
+            var warehouseId = Guid.NewGuid().ToString();
+
+            _supplyStorageMock.Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), warehouseId))
+                .Throws(new StorageException(new InvalidOperationException()));
+
+            Assert.That(() => _supplyBusinessLogic.GetSuppliesByWarehouseId(warehouseId), Throws.TypeOf<StorageException>());
+
+            _supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), warehouseId), Times.Once);
+        }
+
+
+        [Test]
+        public void GetSupplyByData_ReturnRecord_Test()
+        {
+            var supplyId = Guid.NewGuid().ToString();
+            var warehouseId = Guid.NewGuid().ToString();
+
+            var supplyRecord = new SupplyDataModel(
+                supplyId,
+                warehouseId,
+                DateTime.UtcNow,
+                new List<WorkSupplyDataModel> { new WorkSupplyDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10) });
+
+                    _supplyStorageMock
+                .Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()))
+                .Returns(new List<SupplyDataModel> { supplyRecord });
+
+            var result = _supplyBusinessLogic.GetSupplyByData(supplyId);
+
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result, Is.EqualTo(supplyRecord));
+
+            _supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Once);
+        }
+
+        [Test]
+        public void GetSupplyByData_SupplyIdIsNullOrEmpty_ThrowException_Test()
+        {
+            Assert.That(() => _supplyBusinessLogic.GetSupplyByData(null), Throws.TypeOf<ArgumentNullException>());
+            Assert.That(() => _supplyBusinessLogic.GetSupplyByData(string.Empty), Throws.TypeOf<ArgumentNullException>());
+
+            _supplyStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        }
+
+
+        [Test]
+        public void GetSupplyByData_SupplyIdIsNotGuid_ThrowException_Test()
+        {
+            var invalidSupplyId = "invalid-guid";
+
+            Assert.That(() => _supplyBusinessLogic.GetSupplyByData(invalidSupplyId), Throws.TypeOf<ValidationException>());
+
+            _supplyStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        }
+
+
+        [Test]
+        public void GetSupplyByData_StorageThrowsException_ThrowException_Test()
+        {
+            var supplyId = Guid.NewGuid().ToString();
+
+            _supplyStorageMock
+                .Setup(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()))
+                .Throws(new StorageException(new InvalidOperationException()));
+
+            Assert.That(() => _supplyBusinessLogic.GetSupplyByData(supplyId), Throws.TypeOf<StorageException>());
+
+            _supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string>()), Times.Once);
+        }
+
+        [Test]
+        public void CountSupplyByPeriod_ValidWorkIdAndPeriod_ReturnsCorrectQuantity_Test()
+        {
+            var fromDate = DateTime.UtcNow.AddDays(-10);
+            var toDate = DateTime.UtcNow;
+            var workId = Guid.NewGuid().ToString();
+
+            var supplies = new List<SupplyDataModel>
+            {
+                new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), fromDate.AddDays(1),
+                    new List<WorkSupplyDataModel>
+                    {
+                        new(workId, Guid.NewGuid().ToString(), 20),
+                        new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 15)
+	        		}),
+                new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), fromDate.AddDays(2),
+                    new List<WorkSupplyDataModel>
+                    {
+                        new(workId, Guid.NewGuid().ToString(), 30)
+                    })
+            };
+
+            _supplyStorageMock.Setup(x => x.GetList(fromDate, toDate, null)).Returns(supplies);
+
+            var result = _supplyBusinessLogic.CountSupplyByPeriod(workId, fromDate, toDate);
+
+            var expected = 20 + 30; 
+            Assert.That(result, Is.EqualTo(expected));
+
+            _supplyStorageMock.Verify(x => x.GetList(fromDate, toDate, null), Times.Once);
+        }
+
+
+
+
+        [Test]
+        public void InsertSupply_CorrectRecord_Test()
+        {
+            var supplyId = Guid.NewGuid().ToString();
+            var warehouseId = Guid.NewGuid().ToString();
+            var supplyDate = DateTime.UtcNow.AddDays(-10);
+            var products = new List<WorkSupplyDataModel>
+            {
+               new WorkSupplyDataModel(Guid.NewGuid().ToString(), warehouseId, 100)
+            };
+
+            var supply = new SupplyDataModel(supplyId, warehouseId, supplyDate, products);
+
+            _supplyStorageMock.Setup(x => x.GetElementById(supply.Id)).Returns((SupplyDataModel)null);
+            _supplyStorageMock.Setup(x => x.AddElement(It.IsAny<SupplyDataModel>()));
+
+            _supplyBusinessLogic.InsertSupply(supply);
+
+            _supplyStorageMock.Verify(x => x.GetElementById(supply.Id), Times.Once);
+            _supplyStorageMock.Verify(x => x.AddElement(supply), Times.Once);
+        }
+
+
+        [Test]
+        public void InsertSupply_NullRecord_ThrowException_Test()
+        {
+            Assert.That(() => _supplyBusinessLogic.InsertSupply(null), Throws.TypeOf<ArgumentNullException>());
+
+            _supplyStorageMock.Verify(x => x.AddElement(It.IsAny<SupplyDataModel>()), Times.Never);
+        }
+
+        [Test]
+        public void InsertSupply_RecordWithExistingId_ThrowException_Test()
+        {
+            var supplyId = Guid.NewGuid().ToString();
+            var warehouseId = Guid.NewGuid().ToString();
+            var supplyDate = DateTime.UtcNow.AddDays(-10);
+            var products = new List<WorkSupplyDataModel>
+            {
+                new WorkSupplyDataModel(Guid.NewGuid().ToString(), warehouseId, 100)
+            };
+
+            var supply = new SupplyDataModel(supplyId, warehouseId, supplyDate, products);
+
+            _supplyStorageMock.Setup(x => x.GetElementById(supply.Id)).Returns(supply);
+
+            Assert.That(() => _supplyBusinessLogic.InsertSupply(supply), Throws.TypeOf<ElementExistsException>());
+
+            _supplyStorageMock.Verify(x => x.GetElementById(supply.Id), Times.Once);
+            _supplyStorageMock.Verify(x => x.AddElement(It.IsAny<SupplyDataModel>()), Times.Never);
+        }
+
+
+        [Test]
+        public void InsertSupply_WarehouseIdIsNullOrEmpty_ThrowException_Test()
+        {
+            var supplyId = Guid.NewGuid().ToString();
+            var supplyDate = DateTime.UtcNow.AddDays(-10);
+            var products = new List<WorkSupplyDataModel>
+            {
+                new WorkSupplyDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 100)
+             };
+
+            var invalidSupply = new SupplyDataModel(supplyId, "", supplyDate, products);
+
+            Assert.That(() => _supplyBusinessLogic.InsertSupply(invalidSupply), Throws.TypeOf<ValidationException>());
+
+            _supplyStorageMock.Verify(x => x.AddElement(It.IsAny<SupplyDataModel>()), Times.Never);
+        }
+
+
+        [Test]
+        public void InsertSupply_WarehouseIdIsNotGuid_ThrowException_Test()
+        {
+            var supplyId = Guid.NewGuid().ToString();
+            var invalidWarehouseId = "invalid-guid";
+            var supplyDate = DateTime.UtcNow.AddDays(-10);
+            var products = new List<WorkSupplyDataModel>
+            {
+                new WorkSupplyDataModel(Guid.NewGuid().ToString(), invalidWarehouseId, 100)
+            };
+
+            var invalidSupply = new SupplyDataModel(supplyId, invalidWarehouseId, supplyDate, products);
+
+            Assert.That(() => _supplyBusinessLogic.InsertSupply(invalidSupply), Throws.TypeOf<ValidationException>());
+
+            _supplyStorageMock.Verify(x => x.AddElement(It.IsAny<SupplyDataModel>()), Times.Never);
+        }
+
+        [Test]
+        public void InsertSupply_StorageThrowsError_ThrowException_Test()
+        {
+            var supplyId = Guid.NewGuid().ToString();
+            var warehouseId = Guid.NewGuid().ToString();
+            var supplyDate = DateTime.UtcNow.AddDays(-10);
+            var products = new List<WorkSupplyDataModel>
+            {
+                new WorkSupplyDataModel(Guid.NewGuid().ToString(), warehouseId, 100)
+            };
+
+            var supply = new SupplyDataModel(supplyId, warehouseId, supplyDate, products);
+
+            _supplyStorageMock.Setup(x => x.GetElementById(supply.Id)).Returns((SupplyDataModel)null);
+            _supplyStorageMock.Setup(x => x.AddElement(It.IsAny<SupplyDataModel>()))
+                .Throws(new StorageException(new InvalidOperationException()));
+
+            Assert.That(() => _supplyBusinessLogic.InsertSupply(supply), Throws.TypeOf<StorageException>());
+
+            _supplyStorageMock.Verify(x => x.GetElementById(supply.Id), Times.Once);
+            _supplyStorageMock.Verify(x => x.AddElement(supply), Times.Once);
+        }
+
+
+        [Test]
+        public void DeleteSupply_CorrectRecord_Test()
+        {
+            var supplyId = Guid.NewGuid().ToString();
+            var warehouseId = Guid.NewGuid().ToString();
+            var products = new List<WorkSupplyDataModel>
+            {
+                new WorkSupplyDataModel(Guid.NewGuid().ToString(), supplyId, 100)
+            };
+
+            _supplyStorageMock.Setup(x => x.GetElementById(supplyId))
+                .Returns(new SupplyDataModel(supplyId, warehouseId, DateTime.UtcNow, products));
+
+            _supplyBusinessLogic.DeleteSupply(supplyId);
+
+            _supplyStorageMock.Verify(x => x.DelElement(supplyId), Times.Once);
+        }
+
+        [Test]
+        public void DeleteSupply_NullOrEmptyId_ThrowException_Test()
+        {
+            Assert.That(() => _supplyBusinessLogic.DeleteSupply(null), Throws.TypeOf<ArgumentNullException>());
+            Assert.That(() => _supplyBusinessLogic.DeleteSupply(""), Throws.TypeOf<ArgumentNullException>());
+
+            _supplyStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void DeleteSupply_InvalidSupplyId_ThrowException_Test()
+        {
+            var supplyId = "invalid-guid";
+
+            Assert.That(() => _supplyBusinessLogic.DeleteSupply(supplyId), Throws.TypeOf<ValidationException>());
+
+            _supplyStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void DeleteSupply_NotFound_ThrowException_Test()
+        {
+            var supplyId = Guid.NewGuid().ToString();
+            _supplyStorageMock.Setup(x => x.GetElementById(supplyId)).Returns((SupplyDataModel)null);
+
+            Assert.That(() => _supplyBusinessLogic.DeleteSupply(supplyId), Throws.TypeOf<ElementNotFoundException>());
+
+            _supplyStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void DeleteSupply_StorageThrowsError_ThrowException_Test()
+        {
+            var supplyId = Guid.NewGuid().ToString();
+            var warehouseId = Guid.NewGuid().ToString();
+            var products = new List<WorkSupplyDataModel>
+            {
+                new WorkSupplyDataModel(Guid.NewGuid().ToString(), supplyId, 100)
+            };
+
+            _supplyStorageMock.Setup(x => x.GetElementById(supplyId))
+                .Returns(new SupplyDataModel(supplyId, warehouseId, DateTime.UtcNow, products));
+
+            _supplyStorageMock.Setup(x => x.DelElement(supplyId))
+                .Throws(new StorageException(new InvalidOperationException()));
+
+            Assert.That(() => _supplyBusinessLogic.DeleteSupply(supplyId), Throws.TypeOf<StorageException>());
+
+            _supplyStorageMock.Verify(x => x.DelElement(supplyId), Times.Once);
+        }
+    }
+}

TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/WarehouseBusinessLogicContractTests.cs

@@ -0,0 +1,501 @@
+using Moq;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using TwoFromTheCasketContracts.BusinessLogicsContracts;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketBusinessLogic.Implementation;
+using TwoFromTheCasketContracts.Enums;
+using TwoFromTheCasketContracts.StorageContracts;
+using Microsoft.Extensions.Logging;
+
+
+namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
+{
+    [TestFixture]
+    public class WarehouseBusinessLogicContractTests
+    {
+        private WarehouseBusinessLogicContract _warehouseBusinessLogic;
+        private Mock<IWarehouseStorageContract> _warehouseStorageMock;
+        private Mock<IComplitedWorkStorageContract> _complitedWorkStorageMock;
+        private Mock<ISupplyStorageContract> _supplyStorageMock;
+
+
+        [OneTimeSetUp]
+        public void OneTimeSetUp()
+        {
+            _warehouseStorageMock = new Mock<IWarehouseStorageContract>();
+            _complitedWorkStorageMock = new Mock<IComplitedWorkStorageContract>();
+            _supplyStorageMock = new Mock<ISupplyStorageContract>();
+            _warehouseBusinessLogic = new WarehouseBusinessLogicContract(
+                _warehouseStorageMock.Object,
+                new Mock<ILogger>().Object,
+                _complitedWorkStorageMock.Object,
+                _supplyStorageMock.Object
+            );
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            _warehouseStorageMock.Reset();
+            _complitedWorkStorageMock.Reset();
+            _supplyStorageMock.Reset();
+        }
+
+        [Test]
+        public void GetWarehouseByData_CorrectId_ReturnsRecord_Test()
+        {
+            var warehouseId = Guid.NewGuid().ToString();
+            var warehouse = new WarehouseDataModel(warehouseId, "Main Warehouse", "New York", []);
+
+            _warehouseStorageMock.Setup(x => x.GetElementById(warehouseId))
+                .Returns(warehouse);
+
+            var result = _warehouseBusinessLogic.GetWarehouseByData(warehouseId);
+
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result, Is.EqualTo(warehouse));
+
+            _warehouseStorageMock.Verify(x => x.GetElementById(warehouseId), Times.Once);
+        }
+
+        [Test]
+        public void GetWarehouseByData_NullOrEmptyId_ThrowException_Test()
+        {
+
+            Assert.That(() => _warehouseBusinessLogic.GetWarehouseByData(null),
+                Throws.TypeOf<ArgumentNullException>());
+            Assert.That(() => _warehouseBusinessLogic.GetWarehouseByData(""),
+                Throws.TypeOf<ArgumentNullException>());
+
+            _warehouseStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void GetWarehouseByData_InvalidIdFormat_ThrowException_Test()
+        {
+            var invalidId = "invalid-guid";
+
+            Assert.That(() => _warehouseBusinessLogic.GetWarehouseByData(invalidId),
+                Throws.TypeOf<ValidationException>());
+
+            _warehouseStorageMock.Verify(x => x.GetElementById(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void GetWarehouseByData_NotFound_ThrowException_Test()
+        {
+            var warehouseId = Guid.NewGuid().ToString();
+
+            _warehouseStorageMock.Setup(x => x.GetElementById(warehouseId))
+                .Returns((WarehouseDataModel)null);
+
+            Assert.That(() => _warehouseBusinessLogic.GetWarehouseByData(warehouseId),
+                Throws.TypeOf<ElementNotFoundException>());
+
+            _warehouseStorageMock.Verify(x => x.GetElementById(warehouseId), Times.Once);
+        }
+
+        [Test]
+        public void GetWarehouseByData_StorageThrowsException_ThrowException_Test()
+        {
+            var warehouseId = Guid.NewGuid().ToString();
+
+            _warehouseStorageMock.Setup(x => x.GetElementById(warehouseId))
+                .Throws(new StorageException(new InvalidOperationException()));
+
+            Assert.That(() => _warehouseBusinessLogic.GetWarehouseByData(warehouseId),
+                Throws.TypeOf<StorageException>());
+
+            _warehouseStorageMock.Verify(x => x.GetElementById(warehouseId), Times.Once);
+        }
+
+        [Test]
+        public void GetWarehousesByLocation_CorrectLocation_ReturnsList_Test()
+        {
+            var location = "New York";
+            var warehouses = new List<WarehouseDataModel>
+            {
+                new(Guid.NewGuid().ToString(), "Warehouse A", location, []),
+                new(Guid.NewGuid().ToString(), "Warehouse B", location, [])
+            };
+
+            _warehouseStorageMock.Setup(x => x.GetListByLocation(location)).Returns(warehouses);
+
+            var result = _warehouseBusinessLogic.GetWarehousesByLocation(location);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(result, Is.Not.Null);
+                Assert.That(result, Is.EquivalentTo(warehouses));
+            });
+
+            _warehouseStorageMock.Verify(x => x.GetListByLocation(location), Times.Once);
+        }
+
+        [Test]
+        public void GetWarehousesByLocation_LocationIsNullOrEmpty_ThrowException_Test()
+        {
+            Assert.That(() => _warehouseBusinessLogic.GetWarehousesByLocation(null),
+                Throws.TypeOf<ArgumentNullException>());
+            Assert.That(() => _warehouseBusinessLogic.GetWarehousesByLocation(""),
+                Throws.TypeOf<ArgumentNullException>());
+
+            _warehouseStorageMock.Verify(x => x.GetListByLocation(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void GetWarehousesByLocation_NoWarehousesFound_ThrowException_Test()
+        {
+            var location = "Unknown City";
+
+            _warehouseStorageMock.Setup(x => x.GetListByLocation(location))
+                .Returns(new List<WarehouseDataModel>());
+
+            Assert.That(() => _warehouseBusinessLogic.GetWarehousesByLocation(location),
+                Throws.TypeOf<ElementNotFoundException>());
+
+            _warehouseStorageMock.Verify(x => x.GetListByLocation(location), Times.Once);
+        }
+
+        [Test]
+        public void GetWarehousesByLocation_StorageReturnsNull_ThrowException_Test()
+        {
+            var location = "Los Angeles";
+
+            _warehouseStorageMock.Setup(x => x.GetListByLocation(location))
+                .Returns((List<WarehouseDataModel>)null);
+
+            Assert.That(() => _warehouseBusinessLogic.GetWarehousesByLocation(location),
+                Throws.TypeOf<NullListException>());
+
+            _warehouseStorageMock.Verify(x => x.GetListByLocation(location), Times.Once);
+        }
+
+        [Test]
+        public void GetWarehousesByLocation_StorageThrowsException_ThrowException_Test()
+        {
+            var location = "Chicago";
+
+            _warehouseStorageMock.Setup(x => x.GetListByLocation(location))
+                .Throws(new StorageException(new InvalidOperationException()));
+
+            Assert.That(() => _warehouseBusinessLogic.GetWarehousesByLocation(location),
+                Throws.TypeOf<StorageException>());
+
+            _warehouseStorageMock.Verify(x => x.GetListByLocation(location), Times.Once);
+        }
+
+        [Test]
+        public void GetWarehousesByName_CorrectName_ReturnsList_Test()
+        {
+            var warehouseName = "Central Warehouse";
+            var warehouses = new List<WarehouseDataModel>
+            {
+                new(Guid.NewGuid().ToString(), warehouseName, "New York", []),
+                new(Guid.NewGuid().ToString(), warehouseName, "Los Angeles", [])
+            };
+
+            _warehouseStorageMock.Setup(x => x.GetListByName(warehouseName)).Returns(warehouses);
+
+            var result = _warehouseBusinessLogic.GetWarehousesByName(warehouseName);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(result, Is.Not.Null);
+                Assert.That(result, Is.EquivalentTo(warehouses));
+            });
+
+            _warehouseStorageMock.Verify(x => x.GetListByName(warehouseName), Times.Once);
+        }
+
+        [Test]
+        public void GetWarehousesByName_NameIsNullOrEmpty_ThrowException_Test()
+        {
+            Assert.That(() => _warehouseBusinessLogic.GetWarehousesByName(null),
+                Throws.TypeOf<ArgumentNullException>());
+            Assert.That(() => _warehouseBusinessLogic.GetWarehousesByName(""),
+                Throws.TypeOf<ArgumentNullException>());
+
+            _warehouseStorageMock.Verify(x => x.GetListByName(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void GetWarehousesByName_NoWarehousesFound_ThrowException_Test()
+        {
+            var warehouseName = "Unknown Warehouse";
+
+            _warehouseStorageMock.Setup(x => x.GetListByName(warehouseName))
+                .Returns(new List<WarehouseDataModel>());
+
+            Assert.That(() => _warehouseBusinessLogic.GetWarehousesByName(warehouseName),
+                Throws.TypeOf<ElementNotFoundException>());
+
+            _warehouseStorageMock.Verify(x => x.GetListByName(warehouseName), Times.Once);
+        }
+
+        [Test]
+        public void GetWarehousesByName_StorageReturnsNull_ThrowException_Test()
+        {
+            var warehouseName = "Central Warehouse";
+
+            _warehouseStorageMock.Setup(x => x.GetListByName(warehouseName))
+                .Returns((List<WarehouseDataModel>)null);
+
+            Assert.That(() => _warehouseBusinessLogic.GetWarehousesByName(warehouseName),
+                Throws.TypeOf<NullListException>());
+
+            _warehouseStorageMock.Verify(x => x.GetListByName(warehouseName), Times.Once);
+        }
+
+        [Test]
+        public void GetWarehousesByName_StorageThrowsException_ThrowException_Test()
+        {
+            var warehouseName = "East Warehouse";
+
+            _warehouseStorageMock.Setup(x => x.GetListByName(warehouseName))
+                .Throws(new StorageException(new InvalidOperationException()));
+
+            Assert.That(() => _warehouseBusinessLogic.GetWarehousesByName(warehouseName),
+                Throws.TypeOf<StorageException>());
+
+            _warehouseStorageMock.Verify(x => x.GetListByName(warehouseName), Times.Once);
+        }
+
+
+
+        [Test]
+        public void InsertWarehouse_CorrectRecord_Test()
+        {
+            var warehouseId = Guid.NewGuid().ToString();
+            var workWarehouseDataModels = new List<WorkWarehouseDataModel>
+            {
+                new WorkWarehouseDataModel(Guid.NewGuid().ToString(), warehouseId, 10)
+             };
+
+            var warehouse = new WarehouseDataModel(warehouseId, "Main Warehouse", "New York", workWarehouseDataModels);
+
+            _warehouseStorageMock.Setup(x => x.GetElementById(warehouseId)).Returns((WarehouseDataModel?)null);
+            _warehouseStorageMock.Setup(x => x.AddElement(warehouse));
+
+            _warehouseBusinessLogic.InsertWarehouse(warehouse);
+
+            _warehouseStorageMock.Verify(x => x.AddElement(warehouse), Times.Once);
+        }
+
+        [Test]
+        public void CountSupplyRemainderByPeriod_ValidData_ReturnsCorrectRemainder_Test()
+        {
+            var workId = Guid.NewGuid().ToString();
+            var fromDate = DateTime.UtcNow.AddDays(-10);
+            var toDate = DateTime.UtcNow;
+
+            var supplies = new List<SupplyDataModel>
+            {
+               new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), fromDate.AddDays(1),
+                    new List<WorkSupplyDataModel> { new(workId, Guid.NewGuid().ToString(), 10) }),
+                new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), fromDate.AddDays(2),
+                    new List<WorkSupplyDataModel> { new(workId, Guid.NewGuid().ToString(), 15) })
+            };
+
+            var completedWorks = new List<ComplitedWorkDataModel>
+            {
+                new(Guid.NewGuid().ToString(), workId, Guid.NewGuid().ToString(), []),
+                new(Guid.NewGuid().ToString(), workId, Guid.NewGuid().ToString(), [])
+            };
+
+            _supplyStorageMock.Setup(x => x.GetList(fromDate, toDate, It.IsAny<string?>())).Returns(supplies);
+            _complitedWorkStorageMock.Setup(x => x.GetList(fromDate, toDate, null, null, null)).Returns(completedWorks);
+
+            var result = _warehouseBusinessLogic.CountSupplyRemainderByPeriod(workId, fromDate, toDate);
+
+            Assert.That(result, Is.EqualTo(23));
+
+            _supplyStorageMock.Verify(x => x.GetList(fromDate, toDate, It.IsAny<string?>()), Times.Once);
+            _complitedWorkStorageMock.Verify(x => x.GetList(fromDate, toDate, null, null, null), Times.Once);
+        }
+
+        [Test]
+        public void CountSupplyRemainderByPeriod_WorkIdIsNullOrEmpty_ThrowException_Test()
+        {
+            var fromDate = DateTime.UtcNow.AddDays(-10);
+            var toDate = DateTime.UtcNow;
+
+            Assert.That(() => _warehouseBusinessLogic.CountSupplyRemainderByPeriod(null, fromDate, toDate), Throws.TypeOf<ArgumentNullException>());
+            Assert.That(() => _warehouseBusinessLogic.CountSupplyRemainderByPeriod(string.Empty, fromDate, toDate), Throws.TypeOf<ArgumentNullException>());
+
+            _supplyStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), It.IsAny<string?>()), Times.Never);
+            _complitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<DateTime>(), It.IsAny<DateTime>(), null, null, null), Times.Never);
+        }
+
+        [Test]
+        public void InsertWarehouse_NullRecord_ThrowException_Test()
+        {
+            Assert.That(() => _warehouseBusinessLogic.InsertWarehouse(null),
+                Throws.TypeOf<ArgumentNullException>());
+
+            _warehouseStorageMock.Verify(x => x.AddElement(It.IsAny<WarehouseDataModel>()), Times.Never);
+        }
+
+        [Test]
+        public void InsertWarehouse_StorageThrowsException_ThrowException_Test()
+        {
+            var warehouseId = Guid.NewGuid().ToString();
+            var workWarehouseDataModels = new List<WorkWarehouseDataModel>
+            {
+                new WorkWarehouseDataModel(Guid.NewGuid().ToString(), warehouseId, 10)
+            };
+
+            var warehouse = new WarehouseDataModel(warehouseId, "Warehouse A", "Los Angeles", workWarehouseDataModels);
+
+            _warehouseStorageMock
+                .Setup(x => x.AddElement(It.IsAny<WarehouseDataModel>()))
+                .Throws(new StorageException(new InvalidOperationException()));
+
+            Assert.That(() => _warehouseBusinessLogic.InsertWarehouse(warehouse), Throws.TypeOf<StorageException>());
+
+            _warehouseStorageMock.Verify(x => x.AddElement(It.IsAny<WarehouseDataModel>()), Times.Once);
+        }
+
+
+        [Test]
+        public void UpdateWarehouse_CorrectRecord_Test()
+        {
+            var warehouseId = Guid.NewGuid().ToString();
+            var workWarehouseDataModels = new List<WorkWarehouseDataModel>
+            {
+                new WorkWarehouseDataModel(Guid.NewGuid().ToString(), warehouseId, 10)
+            };
+
+            var warehouse = new WarehouseDataModel(warehouseId, "Updated Warehouse", "New York", workWarehouseDataModels);
+
+            _warehouseStorageMock
+                .Setup(x => x.GetElementById(warehouseId))
+                .Returns(warehouse);
+
+            _warehouseStorageMock
+                .Setup(x => x.UpdElement(It.IsAny<WarehouseDataModel>()))
+                .Verifiable();
+
+            _warehouseBusinessLogic.UpdateWarehouse(warehouse);
+
+            _warehouseStorageMock.Verify(x => x.UpdElement(It.IsAny<WarehouseDataModel>()), Times.Once);
+        }
+
+
+        [Test]
+        public void UpdateWarehouse_NullRecord_ThrowException_Test()
+        {
+            Assert.That(() => _warehouseBusinessLogic.UpdateWarehouse(null),
+                Throws.TypeOf<ArgumentNullException>());
+
+            _warehouseStorageMock.Verify(x => x.UpdElement(It.IsAny<WarehouseDataModel>()), Times.Never);
+        }
+
+        [Test]
+        public void UpdateWarehouse_WarehouseNotFound_ThrowException_Test()
+        {
+            var warehouseId = Guid.NewGuid().ToString();
+            var updatedWarehouse = new WarehouseDataModel(warehouseId, "Updated Warehouse", "San Francisco", []);
+
+            _warehouseStorageMock.Setup(x => x.GetElementById(warehouseId)).Returns((WarehouseDataModel)null);
+
+            Assert.That(() => _warehouseBusinessLogic.UpdateWarehouse(updatedWarehouse),
+                Throws.TypeOf<ElementNotFoundException>());
+
+            _warehouseStorageMock.Verify(x => x.GetElementById(warehouseId), Times.Once);
+            _warehouseStorageMock.Verify(x => x.UpdElement(It.IsAny<WarehouseDataModel>()), Times.Never);
+        }
+
+        [Test]
+        public void UpdateWarehouse_StorageThrowsException_ThrowException_Test()
+        {
+            var warehouseId = Guid.NewGuid().ToString();
+            var workWarehouseDataModels = new List<WorkWarehouseDataModel>
+            {
+                new WorkWarehouseDataModel(Guid.NewGuid().ToString(), warehouseId, 10)
+            };
+
+            var updatedWarehouse = new WarehouseDataModel(warehouseId, "Updated Warehouse", "New Location", workWarehouseDataModels);
+
+            _warehouseStorageMock
+                .Setup(x => x.GetElementById(warehouseId))
+                .Returns(updatedWarehouse);
+
+            _warehouseStorageMock
+                .Setup(x => x.UpdElement(It.IsAny<WarehouseDataModel>()))
+                .Throws(new StorageException(new InvalidOperationException()));
+
+            Assert.That(() => _warehouseBusinessLogic.UpdateWarehouse(updatedWarehouse), Throws.TypeOf<StorageException>());
+
+            _warehouseStorageMock.Verify(x => x.UpdElement(It.IsAny<WarehouseDataModel>()), Times.Once);
+        }
+
+
+        [Test]
+        public void DeleteWarehouse_CorrectRecord_Test()
+        {
+            var warehouseId = Guid.NewGuid().ToString();
+            var existingWarehouse = new WarehouseDataModel(warehouseId, "Warehouse 1", "New York", []);
+
+            _warehouseStorageMock.Setup(x => x.GetElementById(warehouseId)).Returns(existingWarehouse);
+            _warehouseStorageMock.Setup(x => x.DelElement(warehouseId));
+
+            _warehouseBusinessLogic.DeleteWarehouse(warehouseId);
+
+            _warehouseStorageMock.Verify(x => x.GetElementById(warehouseId), Times.Once);
+            _warehouseStorageMock.Verify(x => x.DelElement(warehouseId), Times.Once);
+        }
+
+        [Test]
+        public void DeleteWarehouse_IdIsNullOrEmpty_ThrowException_Test()
+        {
+            Assert.That(() => _warehouseBusinessLogic.DeleteWarehouse(null), Throws.TypeOf<ArgumentNullException>());
+            Assert.That(() => _warehouseBusinessLogic.DeleteWarehouse(string.Empty), Throws.TypeOf<ArgumentNullException>());
+
+            _warehouseStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void DeleteWarehouse_IdIsNotGuid_ThrowException_Test()
+        {
+            var invalidId = "invalid-id";
+
+            Assert.That(() => _warehouseBusinessLogic.DeleteWarehouse(invalidId), Throws.TypeOf<ValidationException>());
+
+            _warehouseStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void DeleteWarehouse_WarehouseNotFound_ThrowException_Test()
+        {
+            var warehouseId = Guid.NewGuid().ToString();
+
+            _warehouseStorageMock.Setup(x => x.GetElementById(warehouseId)).Returns((WarehouseDataModel)null);
+
+            Assert.That(() => _warehouseBusinessLogic.DeleteWarehouse(warehouseId), Throws.TypeOf<ElementNotFoundException>());
+
+            _warehouseStorageMock.Verify(x => x.GetElementById(warehouseId), Times.Once);
+            _warehouseStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
+        }
+
+        [Test]
+        public void DeleteWarehouse_StorageThrowsError_ThrowException_Test()
+        {
+            var warehouseId = Guid.NewGuid().ToString();
+            var existingWarehouse = new WarehouseDataModel(warehouseId, "Warehouse 1", "New York", []);
+
+            _warehouseStorageMock.Setup(x => x.GetElementById(warehouseId)).Returns(existingWarehouse);
+            _warehouseStorageMock.Setup(x => x.DelElement(warehouseId)).Throws(new StorageException(new InvalidOperationException()));
+
+            Assert.That(() => _warehouseBusinessLogic.DeleteWarehouse(warehouseId), Throws.TypeOf<StorageException>());
+
+            _warehouseStorageMock.Verify(x => x.GetElementById(warehouseId), Times.Once);
+            _warehouseStorageMock.Verify(x => x.DelElement(warehouseId), Times.Once);
+        }
+    }
+}
+
+

TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/WorkBusinessLogicContractTests.cs

@@ -26,8 +26,8 @@ internal class WorkBusinessLogicContractTests
         _workBusinessLogicContract = new WorkBusinessLogicContract(_workStorageMock.Object, new Mock<ILogger>().Object);
     }
 
-    [SetUp]
-    public void SetUp()
+    [TearDown]
+    public void TearDown()
     {
         _workStorageMock.Reset();
     }

TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/WorkerBusinessLogicContractTests.cs

@@ -29,11 +29,11 @@ namespace TwoFromTheCasketTests.BusinessLogicsContractsTests
             _config = new SalaryConfiguration { Rate = 100 };
         }
 
-        [SetUp]
-        public void SetUp()
-        {
-            _workerStorageContract.Reset();
-        }
+    [SetUp]
+    public void SetUp()
+    {
+        _workerStorageContract.Reset();
+    }
 
 
         [Test]

TwoFromTheCasketContracts/TwoFromTheCasketTests/BusinessLogicsContractsTests/WorkerComplitedWorkBusinessLogicContractTests.cs

@@ -1,357 +0,0 @@
-using Microsoft.Extensions.Logging;
-using Moq;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-using TwoFromTheCasketBusinessLogic.Implementation;
-using TwoFromTheCasketContracts.DataModels;
-using TwoFromTheCasketContracts.Exceptions;
-using TwoFromTheCasketContracts.StorageContracts;
-
-namespace TwoFromTheCasketTests.BusinessLogicsContractsTests;
-
-[TestFixture]
-public class WorkerComplitedWorkBusinessLogicContractTests
-{
-    private WorkerComplitedWorkBusinessLogicContract _workerComplitedWorkBusinessLogicContract;
-    private Mock<IWorkerComplitedWorkStorageContract> _workerComplitedWorkStorageMock;
-
-    [OneTimeSetUp]
-    public void OneTimeSetUp()
-    {
-        _workerComplitedWorkStorageMock = new Mock<IWorkerComplitedWorkStorageContract>();
-        _workerComplitedWorkBusinessLogicContract = new WorkerComplitedWorkBusinessLogicContract(_workerComplitedWorkStorageMock.Object, new Mock<ILogger>().Object);
-    }
-
-    [SetUp]
-    public void SetUp()
-    {
-        _workerComplitedWorkStorageMock.Reset();
-    }
-
-    [Test]
-    public void GetWorkerComplitedWorksByWorker_ReturnListOfRecords_Test()
-    {
-        var workerId = Guid.NewGuid().ToString();
-        var listOriginal = new List<WorkerComplitedWorkDataModel>
-            {
-                new(workerId, Guid.NewGuid().ToString(), 10),
-                new(workerId, Guid.NewGuid().ToString(), 12),
-                new(workerId, Guid.NewGuid().ToString(), 8)
-            };
-        _workerComplitedWorkStorageMock.Setup(x => x.GetList(workerId, null)).Returns(listOriginal);
-
-        var list = _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWorker(workerId);
-
-        Assert.Multiple(() =>
-        {
-            Assert.That(list, Is.Not.Null);
-            Assert.That(list, Is.EquivalentTo(listOriginal));
-        });
-        _workerComplitedWorkStorageMock.Verify(x => x.GetList(workerId, null), Times.Once);
-    }
-
-    [Test]
-    public void GetWorkerComplitedWorksByWorker_ReturnEmptyList_Test()
-    {
-        var workerId = Guid.NewGuid().ToString();
-        _workerComplitedWorkStorageMock.Setup(x => x.GetList(workerId, null)).Returns(new List<WorkerComplitedWorkDataModel>());
-
-        var list = _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWorker(workerId);
-
-        Assert.Multiple(() =>
-        {
-            Assert.That(list, Is.Not.Null);
-            Assert.That(list, Has.Count.EqualTo(0));
-        });
-        _workerComplitedWorkStorageMock.Verify(x => x.GetList(workerId, null), Times.Once);
-    }
-
-    [Test]
-    public void GetWorkerComplitedWorksByWorker_WorkerIdIsNullOrEmpty_ThrowException_Test()
-    {
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWorker(null), Throws.TypeOf<ArgumentNullException>());
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWorker(string.Empty), Throws.TypeOf<ArgumentNullException>());
-        _workerComplitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<string>(), null), Times.Never);
-    }
-
-    [Test]
-    public void GetWorkerComplitedWorksByWorker_WorkerIdIsNotGuid_ThrowException_Test()
-    {
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWorker("invalid_guid"), Throws.TypeOf<ValidationException>());
-        _workerComplitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<string>(), null), Times.Never);
-    }
-
-    [Test]
-    public void GetWorkerComplitedWorksByWorker_ReturnNull_ThrowException_Test()
-    {
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWorker(Guid.NewGuid().ToString()), Throws.TypeOf<NullListException>());
-        _workerComplitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<string>(), null), Times.Once);
-    }
-
-    [Test]
-    public void GetWorkerComplitedWorksByWorker_StorageThrowError_ThrowException_Test()
-    {
-        _workerComplitedWorkStorageMock.Setup(x => x.GetList(It.IsAny<string>(), null)).Throws(new StorageException(new InvalidOperationException()));
-
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWorker(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
-        _workerComplitedWorkStorageMock.Verify(x => x.GetList(It.IsAny<string>(), null), Times.Once);
-    }
-
-    [Test]
-    public void GetWorkerComplitedWorksByWork_ReturnListOfRecords_Test()
-    {
-        var workId = Guid.NewGuid().ToString();
-        var listOriginal = new List<WorkerComplitedWorkDataModel>
-            {
-                new(Guid.NewGuid().ToString(), workId, 10),
-                new(Guid.NewGuid().ToString(), workId, 12),
-                new(Guid.NewGuid().ToString(), workId, 8)
-            };
-        _workerComplitedWorkStorageMock.Setup(x => x.GetList(null, workId)).Returns(listOriginal);
-
-        var list = _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWork(workId);
-
-        Assert.Multiple(() =>
-        {
-            Assert.That(list, Is.Not.Null);
-            Assert.That(list, Is.EquivalentTo(listOriginal));
-        });
-        _workerComplitedWorkStorageMock.Verify(x => x.GetList(null, workId), Times.Once);
-    }
-
-    [Test]
-    public void GetWorkerComplitedWorksByWork_ReturnEmptyList_Test()
-    {
-        var workId = Guid.NewGuid().ToString();
-        _workerComplitedWorkStorageMock.Setup(x => x.GetList(null, workId)).Returns(new List<WorkerComplitedWorkDataModel>());
-
-        var list = _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWork(workId);
-
-        Assert.Multiple(() =>
-        {
-            Assert.That(list, Is.Not.Null);
-            Assert.That(list, Has.Count.EqualTo(0));
-        });
-        _workerComplitedWorkStorageMock.Verify(x => x.GetList(null, workId), Times.Once);
-    }
-
-    [Test]
-    public void GetWorkerComplitedWorksByWork_WorkIdIsNullOrEmpty_ThrowException_Test()
-    {
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWork(null), Throws.TypeOf<ArgumentNullException>());
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWork(string.Empty), Throws.TypeOf<ArgumentNullException>());
-        _workerComplitedWorkStorageMock.Verify(x => x.GetList(null, It.IsAny<string>()), Times.Never);
-    }
-
-    [Test]
-    public void GetWorkerComplitedWorksByWork_WorkIdIsNotGuid_ThrowException_Test()
-    {
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWork("invalid_guid"), Throws.TypeOf<ValidationException>());
-        _workerComplitedWorkStorageMock.Verify(x => x.GetList(null, It.IsAny<string>()), Times.Never);
-    }
-
-    [Test]
-    public void GetWorkerComplitedWorksByWork_ReturnNull_ThrowException_Test()
-    {
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWork(Guid.NewGuid().ToString()), Throws.TypeOf<NullListException>());
-        _workerComplitedWorkStorageMock.Verify(x => x.GetList(null, It.IsAny<string>()), Times.Once);
-    }
-
-    [Test]
-    public void GetWorkerComplitedWorksByWork_StorageThrowError_ThrowException_Test()
-    {
-        _workerComplitedWorkStorageMock.Setup(x => x.GetList(null, It.IsAny<string>())).Throws(new StorageException(new InvalidOperationException()));
-
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.GetWorkerComplitedWorksByWork(Guid.NewGuid().ToString()), Throws.TypeOf<StorageException>());
-        _workerComplitedWorkStorageMock.Verify(x => x.GetList(null, It.IsAny<string>()), Times.Once);
-    }
-
-    [Test]
-    public void InsertWorkerComplitedWork_CorrectRecord_Test()
-    {
-        var flag = false;
-        var record = new WorkerComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 20.5);
-        _workerComplitedWorkStorageMock.Setup(x => x.AddElement(It.IsAny<WorkerComplitedWorkDataModel>()))
-            .Callback((WorkerComplitedWorkDataModel x) =>
-            {
-                flag = x.WorkerId == record.WorkerId &&
-                       x.ComplitedWorkId == record.ComplitedWorkId &&
-                       x.NumberOfWorkingHours == record.NumberOfWorkingHours;
-            });
-
-        _workerComplitedWorkBusinessLogicContract.InsertWorkerComplitedWork(record);
-
-        _workerComplitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Once);
-        Assert.That(flag);
-    }
-
-    [Test]
-    public void InsertWorkerComplitedWork_RecordWithExistsData_ThrowException_Test()
-    {
-        _workerComplitedWorkStorageMock.Setup(x => x.AddElement(It.IsAny<WorkerComplitedWorkDataModel>()))
-            .Throws(new ElementExistsException("Data", "Data"));
-
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.InsertWorkerComplitedWork(
-            new WorkerComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 15.0)),
-            Throws.TypeOf<ElementExistsException>());
-
-        _workerComplitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Once);
-    }
-
-    [Test]
-    public void InsertWorkerComplitedWork_NullRecord_ThrowException_Test()
-    {
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.InsertWorkerComplitedWork(null),
-            Throws.TypeOf<ArgumentNullException>());
-
-        _workerComplitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Never);
-    }
-
-    [Test]
-    public void InsertWorkerComplitedWork_InvalidRecord_ThrowException_Test()
-    {
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.InsertWorkerComplitedWork(
-            new WorkerComplitedWorkDataModel("invalid_guid", "invalid_guid", -10.0)),
-            Throws.TypeOf<ValidationException>());
-
-        _workerComplitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Never);
-    }
-
-    [Test]
-    public void InsertWorkerComplitedWork_StorageThrowError_ThrowException_Test()
-    {
-        _workerComplitedWorkStorageMock.Setup(x => x.AddElement(It.IsAny<WorkerComplitedWorkDataModel>()))
-            .Throws(new StorageException(new InvalidOperationException()));
-
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.InsertWorkerComplitedWork(
-            new WorkerComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5.0)),
-            Throws.TypeOf<StorageException>());
-
-        _workerComplitedWorkStorageMock.Verify(x => x.AddElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Once);
-    }
-
-    [Test]
-    public void UpdateWorkerComplitedWork_CorrectRecord_Test()
-    {
-        var flag = false;
-        var record = new WorkerComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 15.0);
-        _workerComplitedWorkStorageMock.Setup(x => x.UpdElement(It.IsAny<WorkerComplitedWorkDataModel>()))
-            .Callback((WorkerComplitedWorkDataModel x) =>
-            {
-                flag = x.WorkerId == record.WorkerId &&
-                       x.ComplitedWorkId == record.ComplitedWorkId &&
-                       x.NumberOfWorkingHours == record.NumberOfWorkingHours;
-            });
-
-        _workerComplitedWorkBusinessLogicContract.UpdateWorkerComplitedWork(record);
-
-        _workerComplitedWorkStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Once);
-        Assert.That(flag);
-    }
-
-    [Test]
-    public void UpdateWorkerComplitedWork_RecordWithIncorrectData_ThrowException_Test()
-    {
-        _workerComplitedWorkStorageMock.Setup(x => x.UpdElement(It.IsAny<WorkerComplitedWorkDataModel>()))
-            .Throws(new ElementNotFoundException(""));
-
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.UpdateWorkerComplitedWork(
-            new WorkerComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 20.0)),
-            Throws.TypeOf<ElementNotFoundException>());
-
-        _workerComplitedWorkStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Once);
-    }
-
-    [Test]
-    public void UpdateWorkerComplitedWork_NullRecord_ThrowException_Test()
-    {
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.UpdateWorkerComplitedWork(null),
-            Throws.TypeOf<ArgumentNullException>());
-
-        _workerComplitedWorkStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Never);
-    }
-
-    [Test]
-    public void UpdateWorkerComplitedWork_InvalidRecord_ThrowException_Test()
-    {
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.UpdateWorkerComplitedWork(
-            new WorkerComplitedWorkDataModel("invalid_guid", "invalid_guid", -5.0)),
-            Throws.TypeOf<ValidationException>());
-
-        _workerComplitedWorkStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Never);
-    }
-
-    [Test]
-    public void UpdateWorkerComplitedWork_StorageThrowError_ThrowException_Test()
-    {
-        _workerComplitedWorkStorageMock.Setup(x => x.UpdElement(It.IsAny<WorkerComplitedWorkDataModel>()))
-            .Throws(new StorageException(new InvalidOperationException()));
-
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.UpdateWorkerComplitedWork(
-            new WorkerComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 10.0)),
-            Throws.TypeOf<StorageException>());
-
-        _workerComplitedWorkStorageMock.Verify(x => x.UpdElement(It.IsAny<WorkerComplitedWorkDataModel>()), Times.Once);
-    }
-
-    [Test]
-    public void DeleteWorkerComplitedWork_CorrectRecord_Test()
-    {
-        var id = Guid.NewGuid().ToString();
-        var flag = false;
-
-        _workerComplitedWorkStorageMock.Setup(x => x.DelElement(It.Is<string>(x => x == id)))
-            .Callback(() => { flag = true; });
-
-        _workerComplitedWorkBusinessLogicContract.DeleteWorkerComplitedWork(id);
-
-        _workerComplitedWorkStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
-        Assert.That(flag);
-    }
-
-    [Test]
-    public void DeleteWorkerComplitedWork_RecordWithIncorrectId_ThrowException_Test()
-    {
-        var id = Guid.NewGuid().ToString();
-        _workerComplitedWorkStorageMock.Setup(x => x.DelElement(It.IsAny<string>()))
-            .Throws(new ElementNotFoundException($"WorkerComplitedWork with ID {id} not found"));
-
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.DeleteWorkerComplitedWork(id),
-            Throws.TypeOf<ElementNotFoundException>());
-
-        _workerComplitedWorkStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
-    }
-
-    [Test]
-    public void DeleteWorkerComplitedWork_NullOrEmptyId_ThrowException_Test()
-    {
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.DeleteWorkerComplitedWork(null), Throws.TypeOf<ArgumentNullException>());
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.DeleteWorkerComplitedWork(string.Empty), Throws.TypeOf<ArgumentNullException>());
-
-        _workerComplitedWorkStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
-    }
-
-    [Test]
-    public void DeleteWorkerComplitedWork_IdIsNotGuid_ThrowException_Test()
-    {
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.DeleteWorkerComplitedWork("invalid_id"), Throws.TypeOf<ValidationException>());
-
-        _workerComplitedWorkStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Never);
-    }
-
-    [Test]
-    public void DeleteWorkerComplitedWork_StorageThrowError_ThrowException_Test()
-    {
-        var id = Guid.NewGuid().ToString();
-        _workerComplitedWorkStorageMock.Setup(x => x.DelElement(It.IsAny<string>()))
-            .Throws(new StorageException(new InvalidOperationException()));
-
-        Assert.That(() => _workerComplitedWorkBusinessLogicContract.DeleteWorkerComplitedWork(id),
-            Throws.TypeOf<StorageException>());
-
-        _workerComplitedWorkStorageMock.Verify(x => x.DelElement(It.IsAny<string>()), Times.Once);
-    }
-}

TwoFromTheCasketContracts/TwoFromTheCasketTests/ControllersTests/ComplitedWorkControllerTests.cs

@@ -234,6 +234,14 @@ public class ComplitedWorkControllerTests : BaseWebApiControllerTest
         var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date: DateTime.UtcNow);
         var specialization = TwoFromTheCasketDb.InsertSpecializationToDatabaseAndReturn();
         var worker = TwoFromTheCasketDb.InsertWorkerToDatabaseAndReturn(specializationId: specialization.Id);
+        var warehouse = TwoFromTheCasketDb.InsertWarehouseToDatabaseAndReturn();
+        TwoFromTheCasketDb.WorkWarehouses.Add(new Work_Warehouse
+        {
+            WorkId = work.Id,
+            WarehouseId = warehouse.Id,
+            Quantity = 10  
+        });
+        TwoFromTheCasketDb.SaveChanges();
 
         var model = new ComplitedWorkBindingModel
         {
@@ -242,23 +250,31 @@ public class ComplitedWorkControllerTests : BaseWebApiControllerTest
             WorkId = work.Id,
             Date = DateTime.UtcNow,
             Workers = new List<WorkerComplitedWorkBindingModel>
+        {
+            new()
             {
-                new WorkerComplitedWorkBindingModel
-                {
-                   WorkerId = worker.Id,
-                   NumberOfWorkingHours = 8
-                }
+                WorkerId = worker.Id,
+                NumberOfWorkingHours = 15
             }
+        }
         };
 
         var response = await HttpClient.PostAsync("api/ComplitedWork/Register", MakeContent(model));
+
         Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
 
         var entity = TwoFromTheCasketDb.ComplitedWorks.FirstOrDefault(x => x.Id == model.Id);
         Assert.That(entity, Is.Not.Null);
-        Assert.That(entity!.RoomId, Is.EqualTo(model.RoomId));
-        Assert.That(entity.WorkId, Is.EqualTo(model.WorkId));
-        Assert.That(entity.Date.Date, Is.EqualTo(model.Date.Date));
+        Assert.Multiple(() =>
+        {
+            Assert.That(entity!.RoomId, Is.EqualTo(model.RoomId));
+            Assert.That(entity.WorkId, Is.EqualTo(model.WorkId));
+            Assert.That(entity.Date.Date, Is.EqualTo(model.Date.Date));
+        });
+
+        var stock = TwoFromTheCasketDb.WorkWarehouses
+                     .First(x => x.WorkId == work.Id && x.WarehouseId == warehouse.Id);
+        Assert.That(stock.Quantity, Is.EqualTo(10));
     }
 
     [Test]

TwoFromTheCasketContracts/TwoFromTheCasketTests/ControllersTests/SupplyControllerTests.cs

@@ -0,0 +1,243 @@
+using System.Net;
+using TwoFromTheCasketContracts.BindingModels;
+using TwoFromTheCasketContracts.ViewModels;
+using TwoFromTheCasketTests.Infrastructure;
+using TwoFromTheCasketDatabase.Models;
+using TwoFromTheCasketTests.WebApiControllersTests;
+
+namespace TwoFromTheCasketTests.ControllerTests;
+
+[TestFixture]
+public class SupplyControllerTests : BaseWebApiControllerTest
+{
+    [TearDown]
+    public void TearDown()
+    {
+        TwoFromTheCasketDb.ClearTables();
+    }
+
+    [Test]
+    public async Task Try_GetList_Test()
+    {
+        var date = DateTime.UtcNow;
+        var warehouse = TwoFromTheCasketDb.InsertWarehouseToDatabaseAndReturn();
+        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date: date);
+        var supply = TwoFromTheCasketDb.InsertSupplyToDatabaseAndReturn(warehouse.Id, work.Id, date);
+
+        var response = await HttpClient.GetAsync("api/Supply/GetList");
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
+
+        var list = await GetModelFromResponseAsync<List<SupplyViewModel>>(response);
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list.Count, Is.EqualTo(3));
+    }
+
+    [Test]
+    public async Task Try_GetElement_Test()
+    {
+        var date = DateTime.UtcNow;
+        var warehouse = TwoFromTheCasketDb.InsertWarehouseToDatabaseAndReturn();
+        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date: date);
+        var supply = TwoFromTheCasketDb.InsertSupplyToDatabaseAndReturn(warehouse.Id, work.Id, date);
+
+        var response = await HttpClient.GetAsync($"api/Supply/GetRecord/{supply.Id}");
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
+
+        var element = await GetModelFromResponseAsync<SupplyViewModel>(response);
+        Assert.That(element, Is.Not.Null);
+        Assert.That(element.Id, Is.EqualTo(supply.Id));
+    }
+
+    [Test]
+    public async Task Try_GetElement_WhenExists_Test()
+    {
+        var warehouse = TwoFromTheCasketDb.InsertWarehouseToDatabaseAndReturn();
+        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date: DateTime.UtcNow);
+        var supply = TwoFromTheCasketDb.InsertSupplyToDatabaseAndReturn(
+                            warehouse.Id, work.Id, DateTime.UtcNow);
+
+        var response = await HttpClient.GetAsync($"api/Supply/GetRecord/{supply.Id}");
+
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
+
+        var viewModel = await GetModelFromResponseAsync<SupplyViewModel>(response);
+        Assert.Multiple(() =>
+        {
+            Assert.That(viewModel, Is.Not.Null);
+            Assert.That(viewModel!.Id, Is.EqualTo(supply.Id));
+            Assert.That(viewModel.WarehouseId, Is.EqualTo(supply.WarehouseId));
+            Assert.That(viewModel.Works.Count, Is.EqualTo(1));
+            Assert.That(viewModel.Works[0].WorkId, Is.EqualTo(work.Id));
+        });
+    }
+
+    [Test]
+    public async Task Try_GetElement_WhenInvalidGuid_Test()
+    {
+        var response = await HttpClient.GetAsync("api/Supply/GetRecord/not-a-guid");
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+    }
+
+
+    [Test]
+    public async Task Try_GetElement_WhenNotFound_Test()
+    {
+        var response = await HttpClient.GetAsync($"api/Supply/GetRecord/{Guid.NewGuid()}");
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
+    }
+
+    [Test]
+    public async Task Try_Register_Test()
+    {
+        var warehouse = TwoFromTheCasketDb.InsertWarehouseToDatabaseAndReturn();
+        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date: DateTime.UtcNow);
+
+        var model = new SupplyBindingModel
+        {
+            Id = Guid.NewGuid().ToString(),
+            WarehouseId = warehouse.Id,
+            SupplyDate = DateTime.UtcNow,
+            Works = new List<WorkSupplyBindingModel>
+            {
+                new WorkSupplyBindingModel
+                {
+                    WorkId = work.Id,
+                    Quantity = 10
+                }
+            }
+        };
+
+        var response = await HttpClient.PostAsync("api/Supply/Register", MakeContent(model));
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
+
+        var entity = TwoFromTheCasketDb.Supplies.FirstOrDefault(x => x.Id == model.Id);
+        Assert.That(entity, Is.Not.Null);
+        Assert.That(entity.WarehouseId, Is.EqualTo(model.WarehouseId));
+    }
+
+    [Test]
+    public async Task Try_Register_WhenAlreadyExists_Test()
+    {
+        var warehouse = TwoFromTheCasketDb.InsertWarehouseToDatabaseAndReturn();
+        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date: DateTime.UtcNow);
+        var supply = TwoFromTheCasketDb.InsertSupplyToDatabaseAndReturn(warehouse.Id, work.Id, DateTime.UtcNow);
+
+        var model = new SupplyBindingModel
+        {
+            Id = supply.Id,
+            WarehouseId = warehouse.Id,
+            SupplyDate = DateTime.UtcNow,
+            Works = new()
+            {
+                new WorkSupplyBindingModel { WorkId = work.Id, Quantity = 5 }
+            }
+        };
+
+        var response = await HttpClient.PostAsync("api/Supply/Register", MakeContent(model));
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public async Task Try_Register_WhenWarehouseIdNotGuid_Test()
+    {
+        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date : DateTime.UtcNow);
+
+        var model = new SupplyBindingModel
+        {
+            Id = Guid.NewGuid().ToString(),
+            WarehouseId = "not-a-guid",
+            SupplyDate = DateTime.UtcNow,
+            Works = new()
+            {
+                new WorkSupplyBindingModel { WorkId = work.Id, Quantity = 3 }
+            }
+        };
+
+        var response = await HttpClient.PostAsync("api/Supply/Register", MakeContent(model));
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public async Task Try_Register_WhenNoWorks_Test()
+    {
+        var warehouse = TwoFromTheCasketDb.InsertWarehouseToDatabaseAndReturn();
+
+        var model = new SupplyBindingModel
+        {
+            Id = Guid.NewGuid().ToString(),
+            WarehouseId = warehouse.Id,
+            SupplyDate = DateTime.UtcNow,
+            Works = new List<WorkSupplyBindingModel>() 
+        };
+
+        var response = await HttpClient.PostAsync("api/Supply/Register", MakeContent(model));
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public async Task Try_Register_WhenWorkNotFound_Test()
+    {
+        var warehouse = TwoFromTheCasketDb.InsertWarehouseToDatabaseAndReturn();
+
+        var model = new SupplyBindingModel
+        {
+            Id = Guid.NewGuid().ToString(),
+            WarehouseId = warehouse.Id,
+            SupplyDate = DateTime.UtcNow,
+            Works = new()
+            {
+                new WorkSupplyBindingModel { WorkId = Guid.NewGuid().ToString(), Quantity = 2 }
+            }
+        };
+
+        var response = await HttpClient.PostAsync("api/Supply/Register", MakeContent(model));
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.InternalServerError));
+    }
+
+    [Test]
+    public async Task Try_Remove_Test()
+    {
+        var date = DateTime.UtcNow;
+        var warehouse = TwoFromTheCasketDb.InsertWarehouseToDatabaseAndReturn();
+        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date: date);
+        var supply = TwoFromTheCasketDb.InsertSupplyToDatabaseAndReturn(warehouse.Id, work.Id, date);
+
+        var response = await HttpClient.DeleteAsync($"api/Supply/Remove/{supply.Id}");
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
+
+        var fromDb = TwoFromTheCasketDb.Supplies.FirstOrDefault(x => x.Id == supply.Id);
+        Assert.That(fromDb, Is.Null);
+    }
+
+
+    [Test]
+    public async Task Try_Remove_WhenInvalidGuid_Test()
+    {
+        var response = await HttpClient.DeleteAsync("api/Supply/Delete/not-a-guid");
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
+    }
+
+
+    [Test]
+    public async Task Try_Remove_WhenNotFound_Test()
+    {
+        var response = await HttpClient.DeleteAsync($"api/Supply/Delete/{Guid.NewGuid()}");
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
+    }
+
+    [Test]
+    public async Task Try_Remove_WhenAlreadyRemoved_Test()
+    {
+        var warehouse = TwoFromTheCasketDb.InsertWarehouseToDatabaseAndReturn();
+        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn(date: DateTime.UtcNow);
+        var supply = TwoFromTheCasketDb.InsertSupplyToDatabaseAndReturn(
+                            warehouse.Id, work.Id, DateTime.UtcNow);
+
+        var first = await HttpClient.DeleteAsync($"api/Supply/Delete/{supply.Id}");
+        var second = await HttpClient.DeleteAsync($"api/Supply/Delete/{supply.Id}");
+
+        Assert.That(first.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
+        Assert.That(second.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
+    }
+
+}

TwoFromTheCasketContracts/TwoFromTheCasketTests/ControllersTests/WarehouseControllerTests.cs

@@ -0,0 +1,201 @@
+using System.Net;
+using System.Net.Http.Json;
+using TwoFromTheCasketContracts.BindingModels;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.ViewModels;
+using TwoFromTheCasketDatabase.Models;
+using TwoFromTheCasketTests.Infrastructure;
+using TwoFromTheCasketTests.WebApiControllersTests;
+
+namespace TwoFromTheCasketTests.ControllerTests;
+
+[TestFixture]
+public class WarehouseControllerTests : BaseWebApiControllerTest
+{
+    private Warehouse _warehouse = null!;
+
+    [SetUp]
+    public void Setup()
+    {
+        TwoFromTheCasketDb.ClearTables();
+    }
+
+    [OneTimeSetUp]
+    public void OneTimeSetUp()
+    {
+        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn();
+        _warehouse = TwoFromTheCasketDb.InsertWarehouseToDatabaseAndReturn(id: Guid.NewGuid().ToString(), name:"Склад1", "Москва", workid: work.Id);
+    }
+
+    [Test]
+    public async Task Try_GetElementById_WhenValid_Test()
+    {
+        var response = await HttpClient.GetAsync($"api/Warehouse/GetRecord/{_warehouse.Id}");
+        var model = await GetModelFromResponseAsync<WarehouseViewModel>(response);
+
+        Assert.That(model.Id, Is.EqualTo(_warehouse.Id));
+        Assert.That(model.Name, Is.EqualTo("ОбновлённыйСклад"));
+        Assert.That(model.Location, Is.EqualTo("Сочи"));
+    }
+
+    [Test]
+    public async Task Try_GetElementById_WhenInvalidGuid_Test()
+    {
+        var response = await HttpClient.GetAsync("api/Warehouse/GetRecord/not-a-guid");
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public async Task Try_GetElementById_WhenEmptyGuid_Test()
+    {
+        var response = await HttpClient.GetAsync("api/Warehouse/GetRecord/");
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
+    }
+
+    [Test]
+    public async Task Try_GetElementById_WhenNotFound_Test()
+    {
+        var id = Guid.NewGuid().ToString();
+        var response = await HttpClient.GetAsync($"api/Warehouse/GetRecord/{id}");
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
+    }
+
+    [Test]
+    public async Task Try_Register_WhenValid_Test()
+    {
+        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn();
+
+        var id = Guid.NewGuid().ToString();
+        var model = new WarehouseBindingModel
+        {
+            Id = id,
+            Name = "НовыйСклад",
+            Location = "Тула",
+            WorkWarehouseDataModels = new List<WorkWarehouseDataModel>
+            {
+                {
+                    new WorkWarehouseDataModel(work.Id, id, 10)
+                }
+            }
+
+        };
+
+        var response = await HttpClient.PostAsync("api/Warehouse/Register", MakeContent(model));
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
+
+        var entity = TwoFromTheCasketDb.Warehouses.FirstOrDefault(x => x.Id == model.Id);
+        Assert.That(entity, Is.Not.Null);
+        Assert.That(entity!.Name, Is.EqualTo(model.Name));
+        Assert.That(entity.Location, Is.EqualTo(model.Location));
+    }
+
+    [Test]
+    public async Task Try_Register_WhenInvalid_Test()
+    {
+        var model = new WarehouseBindingModel
+        {
+            Id = "",
+            Name = "",
+            Location = ""
+        };
+
+        var response = await HttpClient.PostAsync("api/Warehouse/Register", MakeContent(model));
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public async Task Try_Register_WhenDuplicateId_Test()
+    {
+        var model = new WarehouseBindingModel
+        {
+            Id = _warehouse.Id,
+            Name = "Дубликат",
+            Location = "Самара"
+        };
+
+        var response = await HttpClient.PostAsync("api/Warehouse/Register", MakeContent(model));
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public async Task Try_ChangeInfo_WhenValid_Test()
+    {
+        var work = TwoFromTheCasketDb.InsertWorkToDatabaseAndReturn();
+        var id = _warehouse.Id;
+        var model = new WarehouseBindingModel
+        {
+            Id = id,
+            Name = "ОбновлённыйСклад",
+            Location = "Сочи",
+            WorkWarehouseDataModels = new List<WorkWarehouseDataModel>
+            {
+                {
+                    new WorkWarehouseDataModel(work.Id, id, 10)
+                }
+            }
+
+        };
+
+        var response = await HttpClient.PutAsync("api/Warehouse/ChangeInfo", MakeContent(model));
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
+
+        var updated = TwoFromTheCasketDb.Warehouses.FirstOrDefault(x => x.Id == _warehouse.Id);
+        Assert.That(updated, Is.Not.Null);
+        Assert.That(updated!.Name, Is.EqualTo(_warehouse.Name));
+        Assert.That(updated.Location, Is.EqualTo(_warehouse.Location));
+    }
+
+    [Test]
+    public async Task Try_ChangeInfo_WhenNotFound_Test()
+    {
+        var model = new WarehouseBindingModel
+        {
+            Id = Guid.NewGuid().ToString(),
+            Name = "НесуществующийСклад",
+            Location = "Екатеринбург"
+        };
+
+        var response = await HttpClient.PutAsync("api/Warehouse/ChangeInfo", MakeContent(model));
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public async Task Try_ChangeInfo_WhenInvalid_Test()
+    {
+        var model = new WarehouseBindingModel
+        {
+            Id = _warehouse.Id,
+            Name = "",
+            Location = ""
+        };
+
+        var response = await HttpClient.PutAsync("api/Warehouse/ChangeInfo", MakeContent(model));
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public async Task Try_Remove_WhenValid_Test()
+    {
+        var response = await HttpClient.DeleteAsync($"api/Warehouse/Remove/{_warehouse.Id}");
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NoContent));
+
+        var deleted = TwoFromTheCasketDb.Warehouses.FirstOrDefault(x => x.Id == _warehouse.Id);
+        Assert.That(deleted, Is.Null);
+    }
+
+    [Test]
+    public async Task Try_Remove_WhenInvalidGuid_Test()
+    {
+        var response = await HttpClient.DeleteAsync("api/Warehouse/Remove/not-a-guid");
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+    }
+
+    [Test]
+    public async Task Try_Remove_WhenNotFound_Test()
+    {
+        var response = await HttpClient.DeleteAsync($"api/Warehouse/Remove/{Guid.NewGuid()}");
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.NotFound));
+    }
+
+
+}

TwoFromTheCasketContracts/TwoFromTheCasketTests/DataModelsTests/ComplitedWorkDataModelTests.cs

@@ -53,6 +53,7 @@ internal class ComplitedWorkDataModelTests
     {
         List<WorkerComplitedWorkDataModel> workers = new List<WorkerComplitedWorkDataModel> { new("1", "2", 3) };
 
+
         var complitedWork = CreateDataModel("1", "2", null, workers);
         Assert.That(() => complitedWork.Validate(), Throws.TypeOf<ValidationException>());
 
@@ -65,6 +66,7 @@ internal class ComplitedWorkDataModelTests
     {
         List<WorkerComplitedWorkDataModel> workers = new List<WorkerComplitedWorkDataModel> { new("1", "2", 3) };
 
+
         var complitedWork = CreateDataModel("1", "2", "not-a-guid", workers);
         Assert.That(() => complitedWork.Validate(), Throws.TypeOf<ValidationException>());
     }
@@ -79,6 +81,8 @@ internal class ComplitedWorkDataModelTests
         Assert.That(() => complitedWork.Validate(), Throws.TypeOf<ValidationException>());
     }
 
+
+
     [Test]
     public void AllFieldsIsCorrectTest()
     {
@@ -90,6 +94,7 @@ internal class ComplitedWorkDataModelTests
             new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5)
         };
 
+
         var complitedWork = CreateDataModel(id, workId, roomId, workers);
 
         Assert.That(() => complitedWork.Validate(), Throws.Nothing);

TwoFromTheCasketContracts/TwoFromTheCasketTests/DataModelsTests/SupplyDataModelTests.cs

@@ -0,0 +1,82 @@
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+
+namespace TwoFromTheCasketTests.DataModelsTests;
+
+[TestFixture]
+public class SupplyDataModelTests
+{
+    [Test]
+    public void SupplyIdIsNullOrEmptyTest()
+    {
+        List<WorkSupplyDataModel> products = new List<WorkSupplyDataModel> {new (Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
+
+        var supply = CreateDataModel(null, Guid.NewGuid().ToString(), DateTime.UtcNow, products);
+        Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
+
+        supply = CreateDataModel(string.Empty, Guid.NewGuid().ToString(), DateTime.UtcNow, products);
+        Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void SupplyIdIsNotGuidTest()
+    {
+        List<WorkSupplyDataModel> products = new List<WorkSupplyDataModel> { new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
+
+        var supply = CreateDataModel("1", Guid.NewGuid().ToString(), DateTime.UtcNow, products);
+        Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void WarehouseIdIsNullOrEmptyTest()
+    {
+        List<WorkSupplyDataModel> products = new List<WorkSupplyDataModel> { new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
+
+        var supply = CreateDataModel(Guid.NewGuid().ToString(), null, DateTime.UtcNow, products);
+        Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
+
+        supply = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, DateTime.UtcNow, products);
+        Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void WarehouseIdIsNotGuidTest()
+    {
+        List<WorkSupplyDataModel> products = new List<WorkSupplyDataModel> {new (Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
+
+        var supply = CreateDataModel(Guid.NewGuid().ToString(), "1", DateTime.UtcNow, products);
+        Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void ProductsIsNullOrEmptyTest()
+    {
+        var supply = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), DateTime.UtcNow, new List<WorkSupplyDataModel>());
+        Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
+        supply = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), DateTime.UtcNow, null);
+        Assert.That(() => supply.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void AllFieldsAreCorrectTest()
+    {
+        var id = Guid.NewGuid().ToString();
+        var warehouseId = Guid.NewGuid().ToString();
+        var supplyDate = DateTime.UtcNow;
+        List<WorkSupplyDataModel> products = new List<WorkSupplyDataModel> { new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
+
+        var supply = CreateDataModel(id, warehouseId, supplyDate, products);
+        Assert.That(() => supply.Validate(), Throws.Nothing);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(supply.Id, Is.EqualTo(id));
+            Assert.That(supply.WarehouseId, Is.EqualTo(warehouseId));
+            Assert.That(supply.SupplyDate, Is.EqualTo(supplyDate)); 
+            Assert.That(supply.Works, Is.EqualTo(products));
+        });
+    }
+
+    private static SupplyDataModel CreateDataModel(string? id, string? warehouseId, DateTime supplyDate, List<WorkSupplyDataModel> product)
+        => new(id, warehouseId, supplyDate, product);
+}

TwoFromTheCasketContracts/TwoFromTheCasketTests/DataModelsTests/WarehouseDataModelTests.cs

@@ -0,0 +1,79 @@
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+
+namespace TwoFromTheCasketTests.DataModelsTests;
+
+[TestFixture]
+public class WarehouseDataModelTests
+{
+    [Test]
+    public void WarehouseIdIsNullOrEmptyTest()
+    {
+        List<WorkWarehouseDataModel> WorkWareHouse = new List<WorkWarehouseDataModel> { new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
+        
+        var warehouse = CreateDataModel(null, "Central Warehouse", "123 Main St", WorkWareHouse);
+        Assert.That(() => warehouse.Validate(), Throws.TypeOf<ValidationException>());
+
+        warehouse = CreateDataModel(string.Empty, "Central Warehouse", "123 Main St", WorkWareHouse);
+        Assert.That(() => warehouse.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void WarehouseIdIsNotGuidTest()
+    {
+        List<WorkWarehouseDataModel> WorkWareHouse = new List<WorkWarehouseDataModel> { new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
+
+        var warehouse = CreateDataModel("1", "Central Warehouse", "123 Main St", WorkWareHouse);
+        Assert.That(() => warehouse.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void WarehouseNameIsEmptyTest()
+    {
+        List<WorkWarehouseDataModel> WorkWareHouse = new List<WorkWarehouseDataModel> { new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
+
+        var warehouse = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, "123 Main St", WorkWareHouse);
+        Assert.That(() => warehouse.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void WarehouseLocationIsEmptyTest()
+    {
+        List<WorkWarehouseDataModel> WorkWareHouse = new List<WorkWarehouseDataModel> { new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
+
+        var warehouse = CreateDataModel(Guid.NewGuid().ToString(), "Central Warehouse", string.Empty, WorkWareHouse);
+        Assert.That(() => warehouse.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void WorkWareHouseIsNullOrEmptyTest()
+    {
+        var warehouse = CreateDataModel(Guid.NewGuid().ToString(), "Central Warehouse", string.Empty, null);
+        Assert.That(() => warehouse.Validate(), Throws.TypeOf<ValidationException>());
+        warehouse = CreateDataModel(Guid.NewGuid().ToString(), "Central Warehouse", string.Empty, new List<WorkWarehouseDataModel>());
+        Assert.That(() => warehouse.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void AllFieldsAreCorrectTest()
+    {
+        var id = Guid.NewGuid().ToString();
+        var name = "Central Warehouse";
+        var location = "123 Main St";
+        List<WorkWarehouseDataModel> WorkWareHouse = new List<WorkWarehouseDataModel> { new(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 5) };
+
+        var warehouse = CreateDataModel(id, name, location, WorkWareHouse);
+        Assert.That(() => warehouse.Validate(), Throws.Nothing);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(warehouse.Id, Is.EqualTo(id));
+            Assert.That(warehouse.Name, Is.EqualTo(name));
+            Assert.That(warehouse.Location, Is.EqualTo(location));
+            Assert.That(warehouse.WorkWarehouseDataModels, Is.EqualTo(WorkWareHouse));
+        });
+    }
+
+    private static WarehouseDataModel CreateDataModel(string? id, string name, string location, List<WorkWarehouseDataModel> workWarehouseDataModels)
+        => new(id, name, location, workWarehouseDataModels);
+}

TwoFromTheCasketContracts/TwoFromTheCasketTests/DataModelsTests/WorkDataModelTests.cs

@@ -27,6 +27,7 @@ internal class WorkDataModelTests
     [Test]
     public void DescriptionIsEmptyTest()
     {
+
         var work = CreateDataModel(Guid.NewGuid().ToString(), TypeWork.Plaster, "", DateTime.Now);
         Assert.That(() => work.Validate(), Throws.TypeOf<ValidationException>());
     }
@@ -34,6 +35,7 @@ internal class WorkDataModelTests
     [Test]
     public void DateIsInPastTest()
     {
+        
         var work = CreateDataModel(Guid.NewGuid().ToString(), TypeWork.Plaster, "Штукатурка стен", DateTime.Now.AddDays(-1));
         Assert.That(() => work.Validate(), Throws.TypeOf<ValidationException>());
     }
@@ -41,6 +43,7 @@ internal class WorkDataModelTests
     [Test]
     public void TypeIsNoneTest()
     {
+        
         var work = CreateDataModel(Guid.NewGuid().ToString(), TypeWork.None, "Штукатурка стен", DateTime.Now);
         Assert.That(() => work.Validate(), Throws.TypeOf<ValidationException>());
     }

TwoFromTheCasketContracts/TwoFromTheCasketTests/DataModelsTests/WorkSupplyDataModelTests.cs

@@ -0,0 +1,71 @@
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+
+namespace TwoFromTheCasketTests.DataModelsTests;
+
+[TestFixture]
+public class WorkSupplyDataModelTests
+{
+
+    [Test]
+    public void WorkIdIsNullOrEmptyTest()
+    {
+        var workSupply = CreateDataModel(null, Guid.NewGuid().ToString(), 10);
+        Assert.That(() => workSupply.Validate(), Throws.TypeOf<ValidationException>());
+
+        workSupply = CreateDataModel(string.Empty, Guid.NewGuid().ToString(), 10);
+        Assert.That(() => workSupply.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void WorkIdIsNotGuidTest()
+    {
+        var workSupply = CreateDataModel("1", Guid.NewGuid().ToString(), 10);
+        Assert.That(() => workSupply.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void SupplyIdIsNullOrEmptyTest()
+    {
+        var workSupply = CreateDataModel(Guid.NewGuid().ToString(), null, 10);
+        Assert.That(() => workSupply.Validate(), Throws.TypeOf<ValidationException>());
+
+        workSupply = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, 10);
+        Assert.That(() => workSupply.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void SupplyIdIsNotGuidTest()
+    {
+        var workSupply = CreateDataModel(Guid.NewGuid().ToString(), "1", 10);
+        Assert.That(() => workSupply.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void QuantityIsInvalidTest()
+    {
+        var workSupply = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 0);
+        Assert.That(() => workSupply.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void AllFieldsAreCorrectTest()
+    {
+        var workId = Guid.NewGuid().ToString();
+        var supplyId = Guid.NewGuid().ToString();
+        var quantity = 10;
+
+        var workSupply = CreateDataModel(workId, supplyId, quantity);
+        Assert.That(() => workSupply.Validate(), Throws.Nothing);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(workSupply.WorkId, Is.EqualTo(workId));
+            Assert.That(workSupply.SupplyId, Is.EqualTo(supplyId));
+            Assert.That(workSupply.Quantity, Is.EqualTo(quantity));
+        });
+    }
+
+    private static WorkSupplyDataModel CreateDataModel(string? workId, string? supplyId, double quantity)
+        => new(workId, supplyId, quantity);
+}

TwoFromTheCasketContracts/TwoFromTheCasketTests/DataModelsTests/WorkWarehouseDataModelTests.cs

@@ -0,0 +1,71 @@
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+
+namespace TwoFromTheCasketTests.DataModelsTests;
+
+[TestFixture]
+public class WorkWarehouseDataModelTests
+{
+
+    [Test]
+    public void WorkIdIsNullOrEmptyTest()
+    {
+        var workWarehouse = CreateDataModel(null, Guid.NewGuid().ToString(), 10);
+        Assert.That(() => workWarehouse.Validate(), Throws.TypeOf<ValidationException>());
+
+        workWarehouse = CreateDataModel(string.Empty, Guid.NewGuid().ToString(), 10);
+        Assert.That(() => workWarehouse.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void WorkIdIsNotGuidTest()
+    {
+        var workWarehouse = CreateDataModel("1", Guid.NewGuid().ToString(), 10);
+        Assert.That(() => workWarehouse.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void WarehouseIdIsNullOrEmptyTest()
+    {
+        var workWarehouse = CreateDataModel(Guid.NewGuid().ToString(), null, 10);
+        Assert.That(() => workWarehouse.Validate(), Throws.TypeOf<ValidationException>());
+
+        workWarehouse = CreateDataModel(Guid.NewGuid().ToString(), string.Empty, 10);
+        Assert.That(() => workWarehouse.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void WarehouseIdIsNotGuidTest()
+    {
+        var workWarehouse = CreateDataModel(Guid.NewGuid().ToString(), "1", 10);
+        Assert.That(() => workWarehouse.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void QuantityIsInvalidTest()
+    {
+        var workWarehouse = CreateDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 0);
+        Assert.That(() => workWarehouse.Validate(), Throws.TypeOf<ValidationException>());
+    }
+
+    [Test]
+    public void AllFieldsAreCorrectTest()
+    {
+        var workId = Guid.NewGuid().ToString();
+        var warehouseId = Guid.NewGuid().ToString();
+        var quantity = 10;
+
+        var workWarehouse = CreateDataModel(workId, warehouseId, quantity);
+        Assert.That(() => workWarehouse.Validate(), Throws.Nothing);
+
+        Assert.Multiple(() =>
+        {
+            Assert.That(workWarehouse.WorkId, Is.EqualTo(workId));
+            Assert.That(workWarehouse.WarehouseId, Is.EqualTo(warehouseId));
+            Assert.That(workWarehouse.Quantity, Is.EqualTo(quantity));
+        });
+    }
+
+    private static WorkWarehouseDataModel CreateDataModel(string? workId, string? warehouseId, double quantity)
+        => new(workId, warehouseId, quantity);
+}

TwoFromTheCasketContracts/TwoFromTheCasketTests/Infrastructure/TwoFromTheCasketDbContextExtensions.cs

@@ -1,4 +1,5 @@
 using Microsoft.EntityFrameworkCore;
+using TwoFromTheCasketContracts.DataModels;
 using TwoFromTheCasketContracts.Enums;
 using TwoFromTheCasketContracts.Infastructure.SalaryConfiguration;
 using TwoFromTheCasketDatabase;
@@ -58,6 +59,27 @@ public static class TwoFromTheCasketDbContextExtensions
         return room;
     }
 
+    public static Warehouse InsertWarehouseToDatabaseAndReturn(this TwoFromTheCasketDbContext db,
+    string? id = null,
+    string name = "Default Warehouse",
+    string location = "Default Location",
+    string? workid = null)
+    {
+        db.ChangeTracker.Clear();
+        
+        var entity = new Warehouse
+        {
+            Id = id ?? Guid.NewGuid().ToString(),
+            Name = name,
+            Location = location
+        };
+
+        db.Warehouses.Add(entity);
+        db.SaveChanges();
+
+        return entity;
+    }
+
     public static RoomHistory InsertRoomHistoryToDatabaseAndReturn(this TwoFromTheCasketDbContext db,
         string? id = null, string roomId = "room1", TypeRoom type = TypeRoom.Industrial, string owner = "Старый владелец", DateTime? date = null)
     {
@@ -126,6 +148,49 @@ public static class TwoFromTheCasketDbContextExtensions
         return work;
     }
 
+    public static Supply InsertSupplyToDatabaseAndReturn(
+        this TwoFromTheCasketDbContext db,
+        string warehouseId,
+        string workId,
+        DateTime date,
+        double quantity = 10)
+    {
+        var supplyId = Guid.NewGuid().ToString();
+        var supplyDataModel = new SupplyDataModel(
+            supplyId,
+            warehouseId,
+            date,
+            new List<WorkSupplyDataModel>
+            {
+            new(workId, supplyId, quantity)
+            });
+
+        var supplyEntity = new Supply
+        {
+            Id = supplyDataModel.Id,
+            WarehouseId = supplyDataModel.WarehouseId,
+            SupplyDate = supplyDataModel.SupplyDate
+        };
+
+        foreach (var ws in supplyDataModel.Works)
+        {
+            db.WorkSupplyies.Add(new Work_Supply
+            {
+                SupplyId = supplyEntity.Id,
+                WorkId = ws.WorkId,
+                Quantity = (decimal)ws.Quantity
+            });
+        }
+
+        db.Supplies.Add(supplyEntity);
+        db.SaveChanges();
+
+        return db.Supplies
+                 .Include(s => s.Works)
+                 .First(s => s.Id == supplyEntity.Id);
+    }
+
+
     public static ComplitedWork InsertComplitedWorkToDatabaseAndReturn(this TwoFromTheCasketDbContext db,
     string? id = null, string roomId = "room1", string workId = "work1", DateTime? date = null, WorkerComplitedWork? workerComplitedWork = null)
     {

TwoFromTheCasketContracts/TwoFromTheCasketTests/StorageContracts/BaseStorageContractTest.cs

@@ -5,6 +5,7 @@ using System.Text;
 using System.Threading.Tasks;
 using TwoFromTheCasketTests.Infrastructure;
 using TwoFromTheCasketDatabase;
+using Microsoft.EntityFrameworkCore;
 
 namespace TwoFromTheCasketTests.StorageContracts;
 
@@ -15,8 +16,7 @@ public abstract class BaseStorageContractTest
     [OneTimeSetUp]
     public void OneTimeSetUp()
     {
-        TwoFromTheCasketDb = new TwoFromTheCasketDbContext(new
-            ConfigurationDatabaseTest());
+        TwoFromTheCasketDb = new TwoFromTheCasketDbContext(new ConfigurationDatabaseTest());
         TwoFromTheCasketDb.Database.EnsureDeleted();
         TwoFromTheCasketDb.Database.EnsureCreated();
     }

TwoFromTheCasketContracts/TwoFromTheCasketTests/StorageContracts/ComplitedWorkStorageContractTests.cs

@@ -1,10 +1,11 @@
 using Microsoft.EntityFrameworkCore;
+using Moq;
 using NUnit.Framework;
 using System.Net;
 using TwoFromTheCasketContracts.DataModels;
 using TwoFromTheCasketContracts.Enums;
-using TwoFromTheCasketContracts.Exceptions;
 using TwoFromTheCasketContracts.Infastructure.SalaryConfiguration;
+using TwoFromTheCasketContracts.Exceptions;
 using TwoFromTheCasketDatabase.Implementations;
 using TwoFromTheCasketDatabase.Models;
 
@@ -14,11 +15,17 @@ namespace TwoFromTheCasketTests.StorageContracts;
 public class ComplitedWorkStorageContractTests : BaseStorageContractTest
 {
     private ComplitedWorkStorageContract _complitedWorkStorageContract;
+    private WarehouseStorageContract realStorage;
 
     [SetUp]
     public void SetUp()
     {
-        _complitedWorkStorageContract = new ComplitedWorkStorageContract(TwoFromTheCasketDb);
+        realStorage = new WarehouseStorageContract(TwoFromTheCasketDb);
+
+        _complitedWorkStorageContract = new ComplitedWorkStorageContract(
+            TwoFromTheCasketDb,
+            realStorage
+        );
     }
 
     [TearDown]
@@ -57,17 +64,6 @@ public class ComplitedWorkStorageContractTests : BaseStorageContractTest
         Assert.That(element, Is.Null);
     }
 
-    [Test]
-    public void Try_AddElement_Test()
-    {
-        var complitedWorkDataModel = CreateComplitedWorkDataModel(Guid.NewGuid().ToString());
-        _complitedWorkStorageContract.AddElement(complitedWorkDataModel);
-
-        var element = GetComplitedWorkFromDatabase(complitedWorkDataModel.Id);
-        AssertElement(element, complitedWorkDataModel);
-    }
-
-
     [Test]
     public void Try_AddElement_WhenWorkersAreEmpty_Test()
     {
@@ -82,7 +78,46 @@ public class ComplitedWorkStorageContractTests : BaseStorageContractTest
         );
 
         Assert.That(() => _complitedWorkStorageContract.AddElement(complitedWorkDataModel),
-            Throws.TypeOf<ValidationException>());
+            Throws.TypeOf<ElementNotFoundException>().With.Message.Contains("Not enough work available in warehouses."));
+    }
+
+    [Test]
+    public void Try_AddElement_WhenEnoughWorkAvailable_Test()
+    {
+        var workId = Guid.NewGuid().ToString();
+        InsertWorkToDatabase(workId);
+
+        var warehouse1 = InsertWarehouseToDatabase();
+        var warehouse2 = InsertWarehouseToDatabase();
+
+        InsertWorkToWarehouse(warehouse1.Id, workId, 2);
+        InsertWorkToWarehouse(warehouse2.Id, workId, 3);
+
+        var complitedWorkDataModel = CreateComplitedWorkDataModel(Guid.NewGuid().ToString(), workId);
+
+        _complitedWorkStorageContract.AddElement(complitedWorkDataModel);
+
+        var element = GetComplitedWorkFromDatabase(complitedWorkDataModel.Id);
+        Assert.That(element, Is.Not.Null);
+
+        var remainingWork1 = GetWorkQuantityFromWarehouse(warehouse1.Id, workId);
+        var remainingWork2 = GetWorkQuantityFromWarehouse(warehouse2.Id, workId);
+        Assert.That(remainingWork1 + remainingWork2, Is.EqualTo(4));
+    }
+
+    [Test]
+    public void Try_AddElement_WhenNotEnoughWorkAvailable_Test()
+    {
+        var workId = Guid.NewGuid().ToString();
+        InsertWorkToDatabase(workId);
+
+        var warehouse = InsertWarehouseToDatabase();
+        InsertWorkToWarehouse(warehouse.Id, workId, 0);
+
+        var complitedWorkDataModel = CreateComplitedWorkDataModel(Guid.NewGuid().ToString(), workId);
+
+        Assert.That(() => _complitedWorkStorageContract.AddElement(complitedWorkDataModel),
+            Throws.TypeOf<ElementNotFoundException>().With.Message.Contains("Not enough work available in warehouses."));
     }
 
 
@@ -144,7 +179,7 @@ public class ComplitedWorkStorageContractTests : BaseStorageContractTest
         workId ??= InsertWorkToDatabase(Guid.NewGuid().ToString()).Id;
 
         var workerId = InsertWorkerToDatabase(Guid.NewGuid().ToString()).Id;
-        var workerComplitedWork = new WorkerComplitedWorkDataModel(workerId, id, 8);
+        var workerComplitedWork = new WorkerComplitedWorkDataModel(workerId, id, 15);
 
         return new ComplitedWorkDataModel(
             id,
@@ -247,6 +282,39 @@ public class ComplitedWorkStorageContractTests : BaseStorageContractTest
         return worker;
     }
 
+    private Warehouse InsertWarehouseToDatabase(string name = "Test Warehouse", string location = "Test Location")
+    {
+        var warehouse = new Warehouse
+        {
+            Id = Guid.NewGuid().ToString(),
+            Name = name,
+            Location = location
+        };
+
+        TwoFromTheCasketDb.Warehouses.Add(warehouse);
+        TwoFromTheCasketDb.SaveChanges();
+        return warehouse;
+    }
+
+    private void InsertWorkToWarehouse(string warehouseId, string workId, int quantity)
+    {
+        var workWarehouse = new Work_Warehouse
+        {
+            WorkId = workId,
+            WarehouseId = warehouseId,
+            Quantity = quantity
+        };
+
+        TwoFromTheCasketDb.WorkWarehouses.Add(workWarehouse);
+        TwoFromTheCasketDb.SaveChanges();
+    }
+    private int GetWorkQuantityFromWarehouse(string warehouseId, string workId)
+    {
+        return (int)TwoFromTheCasketDb.WorkWarehouses
+            .Where(x => x.WarehouseId == warehouseId && x.WorkId == workId)
+            .Select(x => x.Quantity)
+            .FirstOrDefault();
+    }
 
     private TwoFromTheCasketDatabase.Models.Specialization InsertSpecializationToDatabase(string id, string name = null, double salary = 50000)
     {

TwoFromTheCasketContracts/TwoFromTheCasketTests/StorageContracts/SupplyStorageContractTests.cs

@@ -0,0 +1,246 @@
+using Microsoft.EntityFrameworkCore;
+using NUnit.Framework;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketDatabase.Implementations;
+using TwoFromTheCasketDatabase.Models;
+
+namespace TwoFromTheCasketTests.StorageContracts;
+
+[TestFixture]
+public class SupplyStorageContractTests : BaseStorageContractTest
+{
+    private SupplyStorageContract _supplyStorageContract;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _supplyStorageContract = new SupplyStorageContract(TwoFromTheCasketDb);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"WorkSupplyies\" CASCADE;");
+        TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"Supplies\" CASCADE;");
+        TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"WorkWarehouses\" CASCADE;");
+        TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"Warehouses\" CASCADE;");
+        TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"Works\" CASCADE;");
+    }
+
+    [Test]
+    public void Try_GetList_WhenHaveRecords_Test()
+    {
+
+        var warehouse1 = InsertWarehouse("MainWarehouse", "Moscow");
+        var supply1 = InsertSupply(warehouse1.Id, DateTime.UtcNow.AddDays(-3));
+        var supply2 = InsertSupply(warehouse1.Id, DateTime.UtcNow.AddDays(-1));
+
+        var list = _supplyStorageContract.GetList(
+            DateTime.UtcNow.AddDays(-7),
+            DateTime.UtcNow.AddDays(1),
+            warehouse1.Id
+        );
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Has.Count.EqualTo(2));
+        AssertElement(list.FirstOrDefault(x => x.Id == supply1.Id), supply1);
+        AssertElement(list.FirstOrDefault(x => x.Id == supply2.Id), supply2);
+    }
+
+    [Test]
+    public void Try_GetList_WhenNoRecords_Test()
+    {
+        var warehouse = InsertWarehouse("SomeWarehouse", "SPB");
+
+        var list = _supplyStorageContract.GetList(
+            DateTime.UtcNow.AddDays(-7),
+            DateTime.UtcNow.AddDays(1),
+            warehouse.Id
+        );
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+
+    [Test]
+    public void Try_GetElementById_WhenHaveRecord_Test()
+    {
+        var warehouse = InsertWarehouse("MainWarehouse", "Moscow");
+        var supply = InsertSupply(warehouse.Id, DateTime.UtcNow);
+
+        var element = _supplyStorageContract.GetElementById(supply.Id);
+
+        AssertElement(element, supply);
+    }
+
+    [Test]
+    public void Try_GetElementById_WhenNoRecord_Test()
+    {
+        var element = _supplyStorageContract.GetElementById(Guid.NewGuid().ToString());
+        Assert.That(element, Is.Null);
+    }
+
+    [Test]
+    public void Try_AddElement_Test()
+    {
+        var warehouse = InsertWarehouse("MainWarehouse", "Moscow");
+        var supply = CreateSupplyDataModel(warehouse.Id);
+
+        _supplyStorageContract.AddElement(supply);
+
+        var fromDb = TwoFromTheCasketDb.Supplies
+            .Include(x => x.Works)
+            .FirstOrDefault(x => x.Id == supply.Id);
+
+        Assert.That(fromDb, Is.Not.Null);
+        AssertElement(fromDb, supply);
+
+        var workId = supply.Works[0].WorkId;
+        var whItem = TwoFromTheCasketDb.WorkWarehouses
+            .FirstOrDefault(x => x.WorkId == workId && x.WarehouseId == supply.WarehouseId);
+        Assert.That(whItem, Is.Not.Null);
+        Assert.That(whItem.Quantity, Is.EqualTo(supply.Works[0].Quantity));
+    }
+
+    [Test]
+    public void Try_DelElement_Test()
+    {
+        var warehouse = InsertWarehouse("MainWarehouse", "Moscow");
+        var supply = InsertSupply(warehouse.Id, DateTime.UtcNow);
+        var workId = InsertWork().Id;
+        InsertWorkSupply(supply.Id, workId, 5);
+
+        InsertWorkToWarehouse(warehouse.Id, workId, 5);
+
+        _supplyStorageContract.DelElement(supply.Id);
+
+        var fromDb = TwoFromTheCasketDb.Supplies
+            .FirstOrDefault(x => x.Id == supply.Id);
+        Assert.That(fromDb, Is.Null);
+
+        var ws = TwoFromTheCasketDb.WorkSupplyies
+            .FirstOrDefault(x => x.SupplyId == supply.Id && x.WorkId == workId);
+        Assert.That(ws, Is.Null);
+
+        var whItem = TwoFromTheCasketDb.WorkWarehouses
+            .FirstOrDefault(x => x.WorkId == workId && x.WarehouseId == warehouse.Id);
+        Assert.That(whItem.Quantity, Is.EqualTo(0));
+    }
+
+    [Test]
+    public void Try_DelElement_WhenNoRecord_Test()
+    {
+        Assert.That(() => _supplyStorageContract.DelElement(Guid.NewGuid().ToString()),
+            Throws.TypeOf<ElementNotFoundException>());
+    }
+    private Warehouse InsertWarehouse(string name, string location)
+    {
+        var warehouse = new Warehouse
+        {
+            Id = Guid.NewGuid().ToString(),
+            Name = name,
+            Location = location
+        };
+        TwoFromTheCasketDb.Warehouses.Add(warehouse);
+        TwoFromTheCasketDb.SaveChanges();
+        return warehouse;
+    }
+
+    private Supply InsertSupply(string warehouseId, DateTime supplyDate)
+    {
+        var supply = new Supply
+        {
+            Id = Guid.NewGuid().ToString(),
+            WarehouseId = warehouseId,
+            SupplyDate = supplyDate
+        };
+        TwoFromTheCasketDb.Supplies.Add(supply);
+        TwoFromTheCasketDb.SaveChanges();
+        return supply;
+    }
+
+    private Work InsertWork(string desc = "Some work")
+    {
+        var work = new Work
+        {
+            Id = Guid.NewGuid().ToString(),
+            Type = TwoFromTheCasketContracts.Enums.TypeWork.None,
+            Description = desc,
+            Date = DateTime.UtcNow
+        };
+        TwoFromTheCasketDb.Works.Add(work);
+        TwoFromTheCasketDb.SaveChanges();
+        return work;
+    }
+    private void InsertWorkSupply(string supplyId, string workId, int quantity)
+    {
+        var ws = new Work_Supply
+        {
+            WorkId = workId,
+            SupplyId = supplyId,
+            Quantity = quantity
+        };
+        TwoFromTheCasketDb.WorkSupplyies.Add(ws);
+        TwoFromTheCasketDb.SaveChanges();
+    }
+
+    private void InsertWorkToWarehouse(string warehouseId, string workId, int quantity)
+    {
+        var existing = TwoFromTheCasketDb.WorkWarehouses
+            .FirstOrDefault(x => x.WarehouseId == warehouseId && x.WorkId == workId);
+
+        if (existing != null)
+        {
+            existing.Quantity += quantity;
+        }
+        else
+        {
+            var ww = new Work_Warehouse
+            {
+                WorkId = workId,
+                WarehouseId = warehouseId,
+                Quantity = quantity
+            };
+            TwoFromTheCasketDb.WorkWarehouses.Add(ww);
+        }
+        TwoFromTheCasketDb.SaveChanges();
+    }
+
+    private SupplyDataModel CreateSupplyDataModel(string warehouseId)
+    {
+        var workId = InsertWork().Id;
+        return new SupplyDataModel(
+            Guid.NewGuid().ToString(),
+            warehouseId,
+            DateTime.UtcNow,
+            new List<WorkSupplyDataModel>
+            {
+                new WorkSupplyDataModel(workId, Guid.NewGuid().ToString(), 5)
+            }
+        );
+    }
+
+    private void AssertElement(Supply? actual, SupplyDataModel expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual!.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.WarehouseId, Is.EqualTo(expected.WarehouseId));
+            Assert.That(actual.SupplyDate, Is.EqualTo(expected.SupplyDate).Within(1).Seconds);
+        });
+    }
+
+    private void AssertElement(SupplyDataModel? actual, Supply expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual!.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.WarehouseId, Is.EqualTo(expected.WarehouseId));
+            Assert.That(actual.SupplyDate, Is.EqualTo(expected.SupplyDate).Within(1).Seconds);
+        });
+    }
+
+}

TwoFromTheCasketContracts/TwoFromTheCasketTests/StorageContracts/WarehouseStorageContract.cs

@@ -0,0 +1,284 @@
+using Microsoft.EntityFrameworkCore;
+using NUnit.Framework;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketDatabase.Implementations;
+using TwoFromTheCasketDatabase.Models;
+
+namespace TwoFromTheCasketTests.StorageContracts;
+
+[TestFixture]
+public class WarehouseStorageContractTests : BaseStorageContractTest
+{
+    private WarehouseStorageContract _warehouseStorageContract;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _warehouseStorageContract = new WarehouseStorageContract(TwoFromTheCasketDb);
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"WorkWarehouses\" CASCADE;");
+        TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"Warehouses\" CASCADE;");
+        TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"Works\" CASCADE;");
+        TwoFromTheCasketDb.Database.ExecuteSqlRaw("TRUNCATE \"ComplitedWorks\" CASCADE;");
+    }
+
+    [Test]
+    public void Try_GetListByLocation_WhenHaveRecords_Test()
+    {
+        var warehouse1 = InsertWarehouseToDatabase("Склад1", "Moscow");
+        InsertWarehouseToDatabase("Склад2", "Moscow");
+        InsertWarehouseToDatabase("Склад3", "SPB");
+
+        var list = _warehouseStorageContract.GetListByLocation("Moscow");
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list.Count, Is.EqualTo(2));
+        AssertElement(list.First(x => x.Id == warehouse1.Id), warehouse1);
+    }
+
+    [Test]
+    public void Try_GetListByLocation_WhenNoRecord_Test()
+    {
+        InsertWarehouseToDatabase("Склад1", "SPB");
+
+        var list = _warehouseStorageContract.GetListByLocation("Moscow");
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+
+    [Test]
+    public void Try_GetListByName_WhenHaveRecords_Test()
+    {
+        var warehouse1 = InsertWarehouseToDatabase("MainStorage", "Moscow");
+        InsertWarehouseToDatabase("MainStorage", "SPB");
+        InsertWarehouseToDatabase("OtherStorage", "SPB");
+
+        var list = _warehouseStorageContract.GetListByName("MainStorage");
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list.Count, Is.EqualTo(2));
+        AssertElement(list.First(x => x.Id == warehouse1.Id), warehouse1);
+    }
+
+    [Test]
+    public void Try_GetListByName_WhenNoRecord_Test()
+    {
+        InsertWarehouseToDatabase("RandomStorage", "SPB");
+
+        var list = _warehouseStorageContract.GetListByName("MainStorage");
+
+        Assert.That(list, Is.Not.Null);
+        Assert.That(list, Is.Empty);
+    }
+
+    [Test]
+    public void Try_GetElementById_WhenHaveRecord_Test()
+    {
+        var warehouse = InsertWarehouseToDatabase("Склад1", "Moscow");
+
+        var element = _warehouseStorageContract.GetElementById(warehouse.Id);
+
+        AssertElement(element, warehouse);
+    }
+
+    [Test]
+    public void Try_GetElementById_WhenNoRecord_Test()
+    {
+        var element = _warehouseStorageContract.GetElementById(Guid.NewGuid().ToString());
+        Assert.That(element, Is.Null);
+    }
+
+    [Test]
+    public void Try_AddElement_Test()
+    {
+        var warehouseData = new WarehouseDataModel(Guid.NewGuid().ToString(), "Склад1", "Moscow", new List<WorkWarehouseDataModel>());
+
+        _warehouseStorageContract.AddElement(warehouseData);
+
+        var fromDb = TwoFromTheCasketDb.Warehouses.FirstOrDefault(x => x.Id == warehouseData.Id);
+        Assert.That(fromDb, Is.Not.Null);
+        AssertElement(fromDb, warehouseData);
+    }
+
+    [Test]
+    public void Try_UpdElement_Test()
+    {
+        var warehouse = InsertWarehouseToDatabase("Склад1", "Moscow");
+
+        var updated = new WarehouseDataModel(warehouse.Id, "NewName", "Kazan", new List<WorkWarehouseDataModel>());
+        _warehouseStorageContract.UpdElement(updated);
+
+        var fromDb = TwoFromTheCasketDb.Warehouses.FirstOrDefault(x => x.Id == warehouse.Id);
+        AssertElement(fromDb, updated);
+    }
+
+    [Test]
+    public void Try_DelElement_Test()
+    {
+        var warehouse = InsertWarehouseToDatabase("СкладForDel", "Location");
+
+        _warehouseStorageContract.DelElement(warehouse.Id);
+
+        var fromDb = TwoFromTheCasketDb.Warehouses.FirstOrDefault(x => x.Id == warehouse.Id);
+        Assert.That(fromDb, Is.Null);
+    }
+
+
+    [Test]
+    public void Try_CheckWorks_WhenEnough_Test()
+    {
+        var workId = Guid.NewGuid().ToString();
+        InsertWorkToDatabase(workId);
+
+        var warehouse1 = InsertWarehouseToDatabase("Склад1", "Moscow");
+        var warehouse2 = InsertWarehouseToDatabase("Склад2", "Moscow");
+        InsertWorkToWarehouse(warehouse1.Id, workId, 2);
+        InsertWorkToWarehouse(warehouse2.Id, workId, 3);
+
+        var complitedWork = CreateComplitedWork(workId);
+
+        var checkResult = _warehouseStorageContract.CheckWorks(complitedWork);
+        Assert.That(checkResult, Is.True);
+    }
+
+    [Test]
+    public void Try_CheckWorks_WhenNotEnough_Test()
+    {
+        var workId = Guid.NewGuid().ToString();
+        InsertWorkToDatabase(workId);
+
+        var warehouse = InsertWarehouseToDatabase("Склад1", "Location");
+        InsertWorkToWarehouse(warehouse.Id, workId, 0);
+
+        var complitedWork = CreateComplitedWork(workId);
+        var checkResult = _warehouseStorageContract.CheckWorks(complitedWork);
+
+        Assert.That(checkResult, Is.False);
+    }
+
+
+    [Test]
+    public void Try_ReserveWorksForComplitedWork_WhenEnough_Test()
+    {
+        var workId = Guid.NewGuid().ToString();
+        InsertWorkToDatabase(workId);
+
+        var warehouse1 = InsertWarehouseToDatabase("Склад1", "Moscow");
+        var warehouse2 = InsertWarehouseToDatabase("Склад2", "SPB");
+        InsertWorkToWarehouse(warehouse1.Id, workId, 2);
+        InsertWorkToWarehouse(warehouse2.Id, workId, 3);
+
+        var complitedWork = CreateComplitedWork(workId);
+
+        _warehouseStorageContract.ReserveWorksForComplitedWork(complitedWork);
+
+        var total = TwoFromTheCasketDb.WorkWarehouses
+            .Where(x => x.WorkId == workId)
+            .Sum(x => x.Quantity);
+
+        Assert.That(total, Is.EqualTo(4));
+    }
+
+    [Test]
+    public void Try_ReserveWorksForComplitedWork_WhenNotEnough_Test()
+    {
+        var workId = Guid.NewGuid().ToString();
+        InsertWorkToDatabase(workId);
+
+        var warehouse = InsertWarehouseToDatabase("Склад1", "Location");
+        InsertWorkToWarehouse(warehouse.Id, workId, 0);
+
+        var complitedWork = CreateComplitedWork(workId);
+        Assert.That(() => _warehouseStorageContract.ReserveWorksForComplitedWork(complitedWork),
+            Throws.TypeOf<ElementNotFoundException>().With.Message.Contains("Not enough work"));
+    }
+    private Warehouse InsertWarehouseToDatabase(string name, string location)
+    {
+        var entity = new Warehouse
+        {
+            Id = Guid.NewGuid().ToString(),
+            Name = name,
+            Location = location
+        };
+        TwoFromTheCasketDb.Warehouses.Add(entity);
+        TwoFromTheCasketDb.SaveChanges();
+        return entity;
+    }
+
+    private Work InsertWorkToDatabase(string workId, string description = "Test work")
+    {
+        var work = new Work
+        {
+            Id = workId,
+            Type = TwoFromTheCasketContracts.Enums.TypeWork.None,
+            Description = description,
+            Date = DateTime.UtcNow
+        };
+        TwoFromTheCasketDb.Works.Add(work);
+        TwoFromTheCasketDb.SaveChanges();
+        return work;
+    }
+
+    private void InsertWorkToWarehouse(string warehouseId, string workId, int quantity)
+    {
+        var existing = TwoFromTheCasketDb.WorkWarehouses
+            .FirstOrDefault(x => x.WarehouseId == warehouseId && x.WorkId == workId);
+
+        if (existing == null)
+        {
+            TwoFromTheCasketDb.WorkWarehouses.Add(new Work_Warehouse
+            {
+                WarehouseId = warehouseId,
+                WorkId = workId,
+                Quantity = quantity
+            });
+        }
+        else
+        {
+            existing.Quantity += quantity;
+        }
+
+        TwoFromTheCasketDb.SaveChanges();
+    }
+
+    private ComplitedWorkDataModel CreateComplitedWork(string workId)
+    {
+        return new ComplitedWorkDataModel(
+            Guid.NewGuid().ToString(),
+            workId,
+            Guid.NewGuid().ToString(),
+            new List<WorkerComplitedWorkDataModel>
+            {
+                new WorkerComplitedWorkDataModel(Guid.NewGuid().ToString(), Guid.NewGuid().ToString(), 8)
+            }
+        );
+    }
+
+    private static void AssertElement(WarehouseDataModel? actual, Warehouse expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual!.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.Name, Is.EqualTo(expected.Name));
+            Assert.That(actual.Location, Is.EqualTo(expected.Location));
+        });
+    }
+
+    private static void AssertElement(Warehouse? actual, WarehouseDataModel expected)
+    {
+        Assert.That(actual, Is.Not.Null);
+        Assert.Multiple(() =>
+        {
+            Assert.That(actual!.Id, Is.EqualTo(expected.Id));
+            Assert.That(actual.Name, Is.EqualTo(expected.Name));
+            Assert.That(actual.Location, Is.EqualTo(expected.Location));
+        });
+    }
+}

TwoFromTheCasketContracts/TwoFromTheCasketWebApi/Adapters/SupplyAdapter.cs

@@ -0,0 +1,106 @@
+using AutoMapper;
+using Microsoft.Extensions.Logging;
+using TwoFromTheCasketContracts.AdapterContracts;
+using TwoFromTheCasketContracts.AdapterContracts.OperationResponses;
+using TwoFromTheCasketContracts.BindingModels;
+using TwoFromTheCasketContracts.BusinessLogicsContracts;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketContracts.ViewModels;
+
+namespace TwoFromTheCasketWebApi.Adapters;
+
+public class SupplyAdapter : ISupplyAdapter
+{
+    private readonly ISupplyBuisnessLogicContract _logic;
+    private readonly ILogger _logger;
+    private readonly IMapper _mapper;
+
+    public SupplyAdapter(ISupplyBuisnessLogicContract logic, ILogger<SupplyAdapter> logger)
+    {
+        _logic = logic;
+        _logger = logger;
+
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.CreateMap<SupplyBindingModel, SupplyDataModel>();
+            cfg.CreateMap<WorkSupplyBindingModel, WorkSupplyDataModel>();
+            cfg.CreateMap<SupplyDataModel, SupplyViewModel>();
+            cfg.CreateMap<WorkSupplyDataModel, WorkSupplyViewModel>();
+        });
+
+        _mapper = config.CreateMapper();
+    }
+
+    public SupplyOperationResponse GetList()
+    {
+        try
+        {
+            var list = _logic.GetSuppliesByPeriod(DateTime.MinValue, DateTime.MaxValue);
+            return SupplyOperationResponse.OK(list.Select(_mapper.Map<SupplyViewModel>).ToList());
+        }
+        catch (Exception ex)
+        {
+            return HandleException(ex);
+        }
+    }
+
+    public SupplyOperationResponse GetElement(string id)
+    {
+        try
+        {
+            var element = _logic.GetSupplyByData(id);
+            return SupplyOperationResponse.OK(_mapper.Map<SupplyViewModel>(element));
+        }
+        catch (Exception ex)
+        {
+            return HandleException(ex);
+        }
+    }
+
+    public SupplyOperationResponse Register(SupplyBindingModel model)
+    {
+        try
+        {
+            var dataModel = _mapper.Map<SupplyDataModel>(model);
+            _logic.InsertSupply(dataModel);
+            return SupplyOperationResponse.NoContent();
+        }
+        catch (Exception ex)
+        {
+            return HandleException(ex);
+        }
+    }
+
+    public SupplyOperationResponse ChangeInfo(SupplyBindingModel model)
+    {
+        return SupplyOperationResponse.BadRequest("Supply update not supported.");
+    }
+
+    public SupplyOperationResponse Remove(string id)
+    {
+        try
+        {
+            _logic.DeleteSupply(id);
+            return SupplyOperationResponse.NoContent();
+        }
+        catch (Exception ex)
+        {
+            return HandleException(ex);
+        }
+    }
+
+    private SupplyOperationResponse HandleException(Exception ex)
+    {
+        _logger.LogError(ex, ex.GetType().Name);
+        return ex switch
+        {
+            ArgumentNullException => SupplyOperationResponse.BadRequest("Data is empty"),
+            ValidationException ve => SupplyOperationResponse.BadRequest(ve.Message),
+            ElementNotFoundException enf => SupplyOperationResponse.NotFound(enf.Message),
+            ElementExistsException eee => SupplyOperationResponse.BadRequest(eee.Message),
+            StorageException se => SupplyOperationResponse.InternalServerError(se.InnerException?.Message ?? se.Message),
+            _ => SupplyOperationResponse.InternalServerError(ex.Message)
+        };
+    }
+}

TwoFromTheCasketContracts/TwoFromTheCasketWebApi/Adapters/WarehouseAdapter.cs

@@ -0,0 +1,117 @@
+using AutoMapper;
+using Microsoft.Extensions.Logging;
+using TwoFromTheCasketContracts.AdapterContracts;
+using TwoFromTheCasketContracts.AdapterContracts.OperationResponses;
+using TwoFromTheCasketContracts.BindingModels;
+using TwoFromTheCasketContracts.BusinessLogicsContracts;
+using TwoFromTheCasketContracts.DataModels;
+using TwoFromTheCasketContracts.Exceptions;
+using TwoFromTheCasketContracts.ViewModels;
+
+namespace TwoFromTheCasketWebApi.Adapters;
+
+public class WarehouseAdapter : IWarehouseAdapter
+{
+    private readonly IWarehouseBuisnessLogicContract _logic;
+    private readonly ILogger _logger;
+    private readonly IMapper _mapper;
+
+    public WarehouseAdapter(IWarehouseBuisnessLogicContract logic, ILogger<WarehouseAdapter> logger)
+    {
+        _logic = logic;
+        _logger = logger;
+
+        var config = new MapperConfiguration(cfg =>
+        {
+            cfg.CreateMap<WarehouseBindingModel, WarehouseDataModel>();
+            cfg.CreateMap<WarehouseDataModel, WarehouseViewModel>();
+        });
+
+        _mapper = config.CreateMapper();
+    }
+
+    public WarehouseOperationResponse GetList()
+    {
+        try
+        {
+            var list = _logic.GetWarehousesByName(string.Empty);
+            return WarehouseOperationResponse.OK(list.Select(_mapper.Map<WarehouseViewModel>).ToList());
+        }
+        catch (NullListException)
+        {
+            return WarehouseOperationResponse.NotFound("The list is not initialized");
+        }
+        catch (Exception ex)
+        {
+            return HandleException(ex);
+        }
+    }
+
+    public WarehouseOperationResponse GetElement(string id)
+    {
+        try
+        {
+            var element = _logic.GetWarehouseByData(id);
+            return WarehouseOperationResponse.OK(_mapper.Map<WarehouseViewModel>(element));
+        }
+        catch (Exception ex)
+        {
+            return HandleException(ex);
+        }
+    }
+
+    public WarehouseOperationResponse Register(WarehouseBindingModel model)
+    {
+        try
+        {
+            var dataModel = _mapper.Map<WarehouseDataModel>(model);
+            _logic.InsertWarehouse(dataModel);
+            return WarehouseOperationResponse.NoContent();
+        }
+        catch (Exception ex)
+        {
+            return HandleException(ex);
+        }
+    }
+
+    public WarehouseOperationResponse ChangeInfo(WarehouseBindingModel model)
+    {
+        try
+        {
+            var dataModel = _mapper.Map<WarehouseDataModel>(model);
+            _logic.UpdateWarehouse(dataModel);
+            return WarehouseOperationResponse.NoContent();
+        }
+        catch (Exception ex)
+        {
+            return HandleException(ex);
+        }
+    }
+
+    public WarehouseOperationResponse Remove(string id)
+    {
+        try
+        {
+            _logic.DeleteWarehouse(id);
+            return WarehouseOperationResponse.NoContent();
+        }
+        catch (Exception ex)
+        {
+            return HandleException(ex);
+        }
+    }
+
+    private WarehouseOperationResponse HandleException(Exception ex)
+    {
+        _logger.LogError(ex, ex.GetType().Name);
+        return ex switch
+        {
+            ArgumentNullException => WarehouseOperationResponse.BadRequest("Data is empty"),
+            ValidationException ve => WarehouseOperationResponse.BadRequest(ve.Message),
+            ElementNotFoundException enf => WarehouseOperationResponse.NotFound(enf.Message),
+            ElementExistsException eee => WarehouseOperationResponse.BadRequest(eee.Message),
+            StorageException se => WarehouseOperationResponse.InternalServerError(se.InnerException?.Message ?? se.Message),
+            _ => WarehouseOperationResponse.InternalServerError(ex.Message)
+        };
+    }
+}

TwoFromTheCasketContracts/TwoFromTheCasketWebApi/Controllers/SupplyController.cs

@@ -0,0 +1,32 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using TwoFromTheCasketContracts.AdapterContracts;
+using TwoFromTheCasketContracts.BindingModels;
+
+namespace TwoFromTheCasketWebApi.Controllers;
+
+[Authorize]
+[ApiController]
+[Produces("application/json")]
+[Route("api/[controller]/[action]")]
+public class SupplyController : ControllerBase
+{
+    private readonly ISupplyAdapter _adapter;
+
+    public SupplyController(ISupplyAdapter adapter) => _adapter = adapter;
+
+    [HttpGet]
+    public IActionResult GetList() => _adapter.GetList().GetResponse(Request, Response);
+
+    [HttpGet("{id}")]
+    public IActionResult GetRecord(string id) => _adapter.GetElement(id).GetResponse(Request, Response);
+
+    [HttpPost]
+    public IActionResult Register([FromBody] SupplyBindingModel model) => _adapter.Register(model).GetResponse(Request, Response);
+
+    [HttpPut]
+    public IActionResult ChangeInfo([FromBody] SupplyBindingModel model) => _adapter.ChangeInfo(model).GetResponse(Request, Response);
+
+    [HttpDelete("{id}")]
+    public IActionResult Remove(string id) => _adapter.Remove(id).GetResponse(Request, Response);
+}

TwoFromTheCasketContracts/TwoFromTheCasketWebApi/Controllers/WarehouseController.cs

@@ -0,0 +1,32 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using TwoFromTheCasketContracts.AdapterContracts;
+using TwoFromTheCasketContracts.BindingModels;
+
+namespace TwoFromTheCasketWebApi.Controllers;
+
+[Authorize]
+[ApiController]
+[Produces("application/json")]
+[Route("api/[controller]/[action]")]
+public class WarehouseController : ControllerBase
+{
+    private readonly IWarehouseAdapter _adapter;
+
+    public WarehouseController(IWarehouseAdapter adapter) => _adapter = adapter;
+
+    [HttpGet]
+    public IActionResult GetList() => _adapter.GetList().GetResponse(Request, Response);
+
+    [HttpGet("{id}")]
+    public IActionResult GetRecord(string id) => _adapter.GetElement(id).GetResponse(Request, Response);
+
+    [HttpPost]
+    public IActionResult Register([FromBody] WarehouseBindingModel model) => _adapter.Register(model).GetResponse(Request, Response);
+
+    [HttpPut]
+    public IActionResult ChangeInfo([FromBody] WarehouseBindingModel model) => _adapter.ChangeInfo(model).GetResponse(Request, Response);
+
+    [HttpDelete("{id}")]
+    public IActionResult Remove(string id) => _adapter.Remove(id).GetResponse(Request, Response);
+}