public async Task PostItemComputer(ItemComputer itemComputer)
        {
            var registrationDate       = DateTime.Now;
            var dateYearsPeriod        = registrationDate.AddYears(4).Year;
            var idScheduleItemComputer = Guid.NewGuid();

            ScheduleItemComputer           scheduleItemComputer = new ScheduleItemComputer();
            ScheduleMaintenanceItem        scheduleMaintenanceItem;
            List <ScheduleMaintenanceItem> scheduleMaintenanceItems = new List <ScheduleMaintenanceItem>();
            Schedule        schedule;
            List <Schedule> schedules = new List <Schedule>();

            var listMaintenanceItems = await _context.MaintenanceItems.Where(mi => mi.ItemId == itemComputer.ItemId).ToListAsync();

            itemComputer.RegistrationDate = registrationDate;

            scheduleItemComputer.Id         = idScheduleItemComputer;
            scheduleItemComputer.ComputerId = itemComputer.ComputerId;
            scheduleItemComputer.ItemId     = itemComputer.ItemId;

            foreach (var maintenanceItem in listMaintenanceItems)
            {
                scheduleMaintenanceItem = new ScheduleMaintenanceItem();

                scheduleMaintenanceItem.Id = Guid.NewGuid();
                scheduleMaintenanceItem.ScheduleItemComputerId = scheduleItemComputer.Id;
                scheduleMaintenanceItem.MaintenanceId          = maintenanceItem.MaintenanceId;

                scheduleMaintenanceItems.Add(scheduleMaintenanceItem);
            }

            foreach (var scheduleMI in scheduleMaintenanceItems)
            {
                var dateAddMonth = registrationDate;

                while (dateAddMonth.Year < dateYearsPeriod)
                {
                    schedule = new Schedule();

                    schedule.Id = Guid.NewGuid();
                    schedule.ScheduleMaintenanceItemId = scheduleMI.Id;
                    schedule.Status = Status.Pending;

                    dateAddMonth = dateAddMonth.AddMonths(listMaintenanceItems.Find(mi => mi.MaintenanceId == scheduleMI.MaintenanceId).Period);

                    schedule.MaintenanceDate = dateAddMonth;

                    schedules.Add(schedule);
                }
            }

            _context.ItemComputers.Add(itemComputer);
            _context.ScheduleItemComputers.Add(scheduleItemComputer);
            _context.ScheduleMaintenanceItems.AddRange(scheduleMaintenanceItems);
            _context.Schedules.AddRange(schedules);
        }
        public async Task <ActionResult <ItemComputer> > DeleteItemComputer(Guid computerId, Guid itemId)
        {
            var itemComputer = await _context.ItemComputers.FindAsync(computerId, itemId);

            if (itemComputer == null)
            {
                return(null);
            }

            _context.ItemComputers.Remove(itemComputer);

            ScheduleItemComputer scheduleItemComputer = await _context.ScheduleItemComputers.Where(sic => sic.ComputerId == computerId &&
                                                                                                   sic.ItemId == sic.ItemId)
                                                        .FirstOrDefaultAsync();

            if (scheduleItemComputer != null)
            {
                List <ScheduleMaintenanceItem> scheduleMaintenanceItemsList = new List <ScheduleMaintenanceItem>();

                var smiList = await _context.ScheduleMaintenanceItems.Where(smi => smi.ScheduleItemComputerId == scheduleItemComputer.Id
                                                                            ).ToListAsync();

                scheduleMaintenanceItemsList.AddRange(smiList);

                if (scheduleMaintenanceItemsList.Count > 0)
                {
                    List <Schedule> schedulesList = new List <Schedule>();

                    foreach (var smiObj in scheduleMaintenanceItemsList)
                    {
                        var sList = await _context.Schedules.Where(s => s.ScheduleMaintenanceItemId == smiObj.Id).ToListAsync();

                        schedulesList.AddRange(sList);
                    }

                    if (schedulesList.Count > 0)
                    {
                        _context.Schedules.RemoveRange(schedulesList);
                    }

                    _context.ScheduleMaintenanceItems.RemoveRange(scheduleMaintenanceItemsList);
                }

                _context.ScheduleItemComputers.Remove(scheduleItemComputer);
            }

            await _context.SaveChangesAsync();

            return(itemComputer);
        }