private async Task <bool> CompareDaysFromTurnover(TripOnRouteWithStationsDto input)
        {
            var sqlRRoute = new RoutesRepository(_logger);
            var route     = await sqlRRoute.ById(input.RouteId);

            if (route.TurnoverId == null)
            {
                throw new ValidationException("У данного маршрута отсутсвует цикловой график");
            }
            var sqlRTurnover = new TurnoversRepoisitory(_logger);
            var turnover     = await sqlRTurnover.ById((int)route.TurnoverId);

            var sqlRDaysOnRoute         = new DayOfRoutesRepoisitory(_logger);
            var daysOfRouteFromTurnover = await sqlRDaysOnRoute.DaysByTurnoverId(turnover.Id);

            var daysFromTurnover = daysOfRouteFromTurnover.Select(x => x.Day).ToList();

            daysFromTurnover.Sort();
            input.Days.Sort();

            var isgoodTrip = true;

            foreach (var d in daysFromTurnover)
            {
                if (!input.Days.Any(x => x.Equals(d)))
                {
                    isgoodTrip = false;
                }
            }
            if (isgoodTrip)
            {
                return(true);
            }
            return(false);
        }
        public async Task Delete(int id)
        {
            await CheckPermission();

            var sqlR = new TurnoversRepoisitory(_logger);
            await sqlR.Delete(id);
        }
        public async Task <JsonResult> GetAll(int skip, int limit, string filter = null)
        {
            await CheckPermission();

            var er     = new TurnoversRepoisitory(_logger);
            var result = await er.GetAll(skip, limit, filter);

            return(Json(result));
        }
        public async Task <JsonResult> AddOrUpdate([FromBody] Turnover input)
        {
            //await CheckPermission();
            //if (input.Days == null || input.Days.Count == 0)
            //    throw new ValidationException("Не заполнены дни циклового графика");

            var sqlR = new TurnoversRepoisitory(_logger);

            if (input.Id != 0)
            {
                return(Json(await sqlR.Update(input)));
            }
            return(Json(await sqlR.Add(input)));
        }
        /// <summary>
        /// Отдает маршруты с временными промежутками то и рейсов для ебучего расписания
        /// </summary>
        public async Task <RoutesWithTimelinePaging> GetRoutesWithTimeline(int turnoverId, int skip, int limit, int?routeId = null)
        {
            RoutesWithTripsAndToPaging data;

            if (routeId != null)
            {
                data = await GetRoutesWithTripsAndToByTurnoverId(turnoverId, skip, limit, routeId);
            }
            else
            {
                data = await GetRoutesWithTripsAndToByTurnoverId(turnoverId, skip, limit);
            }

            var result = new RoutesWithTimelinePaging {
                Total = data.Total, Data = new List <ScheduleRouteTripsTo>()
            };

            foreach (var item in data.Data.OrderBy(x => int.Parse("0" + Regex.Match(x.Name, "(\\d+)").Value)))
            {
                var toAdd = new ScheduleRouteTripsTo();
                toAdd.RouteId   = item.Id;
                toAdd.Mileage   = item.Mileage;
                toAdd.RouteName = item.Name;
                toAdd.TimeLines = await TimelineFromTrips(item.Trips);

                var timelineFromInspectionRoutes = TimelineFromInspectionRoutes(item.InspectionRoutes);
                if (timelineFromInspectionRoutes.Count > 0)
                {
                    toAdd.TimeLines.AddRange(timelineFromInspectionRoutes);
                }
                result.Data.Add(toAdd);
            }

            var sqlRTurnover    = new TurnoversRepoisitory(_logger);
            var sqlRDirection   = new DirectionsRepository(_logger);
            var sqlRDayOfRoutes = new DayOfRoutesRepoisitory(_logger);

            var turnover = await sqlRTurnover.ById(turnoverId);

            result.TurnoverName = turnover.Name;
            var direction = await sqlRDirection.ById(turnover.DirectionId);

            result.DirectionName = direction?.Name;

            var turnoversDays = await sqlRDayOfRoutes.DaysByTurnoverId(turnoverId);

            result.Days = turnoversDays.Select(x => x.Day).ToList();

            return(result);
        }
        public async Task DeleteTurnoverWithDays(int id)
        {
            ////Начинаем блядь КВН
            using (var transaction = new TransactionScope(asyncFlowOption: TransactionScopeAsyncFlowOption.Enabled))
            {
                var sqlRTurnovers = new TurnoversRepoisitory(_logger);
                var sqlRDays      = new DayOfRoutesRepoisitory(_logger);
                var currentDays   = await sqlRDays.DaysByTurnoverId(id);

                foreach (var currentDay in currentDays)
                {
                    await sqlRDays.Delete(currentDay.Id);
                }
                await sqlRTurnovers.Delete(id);

                transaction.Complete();
            }
        }
        /// <summary>
        /// Добавить тарновера с днями в цикловой график
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task <TurnoverWithDays> AddTurnoverWithDays(TurnoverWithDays input)
        {
            //Начинаем блядь КВН
            using (var transaction = new TransactionScope(asyncFlowOption: TransactionScopeAsyncFlowOption.Enabled))
            {
                var sqlRTurnovers = new TurnoversRepoisitory(_logger);
                var sqlRDays      = new DayOfRoutesRepoisitory(_logger);

                var turnover = await sqlRTurnovers.Add(_mapper.Map <TurnoverWithDays, Turnover>(input));

                var result = _mapper.Map <Turnover, TurnoverWithDays>(turnover);
                result.Days = new List <DayOfWeek>();
                foreach (var inputDay in input.Days)
                {
                    var day = await sqlRDays.Add(new DayOfRoute { TurnoverId = result.Id, Day = inputDay });

                    result.Days.Add(day.Day);
                }
                transaction.Complete();
                return(result);
            }
        }
        public async Task <TurnoverWithDays> UpdateTurnoverWithDays(TurnoverWithDays input)
        {
            //Начинаем блядь КВН
            using (var transaction = new TransactionScope(asyncFlowOption: TransactionScopeAsyncFlowOption.Enabled))
            {
                var sqlRTurnovers = new TurnoversRepoisitory(_logger);
                var sqlRDays      = new DayOfRoutesRepoisitory(_logger);

                var turnover = await sqlRTurnovers.Update(_mapper.Map <TurnoverWithDays, Turnover>(input));

                var result      = _mapper.Map <Turnover, TurnoverWithDays>(turnover);
                var currentDays = await sqlRDays.DaysByTurnoverId(input.Id);

                result.Days = new List <DayOfWeek>();
                foreach (var inputDay in input.Days)
                {
                    if (currentDays.Any(x => x.Day.Equals(inputDay)))
                    {
                        result.Days.Add(inputDay);
                        continue;
                    }
                    var day = await sqlRDays.Add(new DayOfRoute { TurnoverId = input.Id, Day = inputDay });

                    result.Days.Add(day.Day);
                }

                foreach (var currentDay in currentDays)
                {
                    if (!input.Days.Any(x => x.Equals(currentDay.Day)))
                    {
                        await sqlRDays.Delete(currentDay.Id);
                    }
                }

                transaction.Complete();
                return(result);
            }
        }
        public async Task <TurnoversWithDaysPaging> GetTurnoversWithDays(int skip, int limit)
        {
            var sqlR      = new TurnoversRepoisitory(_logger);
            var turnovers = await sqlR.GetAll(skip, limit, null);

            var result = new TurnoversWithDaysPaging {
                Data = new List <TurnoverWithDays>(), Total = turnovers.Data.Count
            };
            var sqlRDays = new DayOfRoutesRepoisitory(_logger);

            foreach (var turnover in turnovers.Data)
            {
                result.Data.Add(new TurnoverWithDays
                {
                    Name        = turnover.Name,
                    DirectionId = turnover.DirectionId,
                    Id          = turnover.Id,
                    Days        = (await sqlRDays.DaysByTurnoverId(turnover.Id)).Select(x => x.Day).ToList()
                });
            }

            return(result);
        }