Exemplo n.º 1
0
        /// <summary>
        /// То2 таблица
        /// </summary>
        private static async Task <ChangedTo2OrCtoDto> GetTo2OrCto(GetRouteInformationTableRequest input, ILogger logger)
        {
            var sqlRPlaneInspections   = new PlanedInspectionRoutesRepository(logger);
            var sqlRChangedInspections = new ChangedPlanedInspectionRoutesRepository(logger);

            var planedInspection = await sqlRPlaneInspections.ById(input.EntityId);

            var changedInspection = await sqlRChangedInspections.ByPlanedInspectionRouteId(planedInspection.Id);

            var sqlRTrains            = new TrainRepository(logger);
            var sqlRPlanedRouteTrains = new PlanedRouteTrainsRepository(logger);
            var sqlRRoute             = new RoutesRepository(logger);

            var planedRouteTrain = await sqlRPlanedRouteTrains.ById(input.PlanedRouteTrainId);

            var route = await sqlRRoute.ById(planedRouteTrain.RouteId);

            var train = await sqlRTrains.ById(planedRouteTrain.TrainId);


            var result = new ChangedTo2OrCtoDto
            {
                Id        = planedInspection.Id,
                RouteName = route.Name,
                TrainName = train.Name,
                Plan      = new ChangedTo2OrCtoDto.Planned
                {
                    DateStart = planedInspection.Start.ToFuckingGenaFormat(planedRouteTrain.Date),
                    DateEnd   = planedInspection.End.ToFuckingGenaFormat(planedRouteTrain.Date)
                },
                Fact = new ChangedTo2OrCtoDto.Actual
                {
                    DateStart = planedInspection.Start.ToFuckingGenaFormat(planedRouteTrain.Date),
                    DateEnd   = planedInspection.End.ToFuckingGenaFormat(planedRouteTrain.Date),
                    Canseled  = false
                }
            };

            if (changedInspection != null)
            {
                result.Fact.DateStart = changedInspection.Start.ToFuckingGenaFormat(planedRouteTrain.Date);
                result.Fact.DateEnd   = changedInspection.End.ToFuckingGenaFormat(planedRouteTrain.Date);
                if (changedInspection.Droped)
                {
                    result.Fact.Canseled = changedInspection.Droped;
                }
            }

            return(result);
        }
        public async Task DeleteFromPlanedRouteTrains(int planedRouteTrainsId)
        {
            using (var transaction = new TransactionScope(asyncFlowOption: TransactionScopeAsyncFlowOption.Enabled))
            {
                var sqlRPlanedInspectionOnRoutes = new PlanedInspectionRoutesRepository(_logger);
                var sqlRPlaneStations            = new PlanedStationOnTripsRepository(_logger);
                var sqlRPlaneBrigades            = new PlaneBrigadeTrainsRepository(_logger);
                var sqlRPlanedRouteTrains        = new PlanedRouteTrainsRepository(_logger);

                var sqlRChangedInspections = new ChangedPlanedInspectionRoutesRepository(_logger);
                var sqlRChangedBrigades    = new ChangePlaneBrigadeTrainsRepository(_logger);
                var sqlRChangedStations    = new ChangePlaneStantionOnTripsRepository(_logger);

                //ебаем нахуй инспекции
                var planedInspections = await sqlRPlanedInspectionOnRoutes.ByPlanedRouteTrainId(planedRouteTrainsId);

                foreach (var planedInspection in planedInspections)
                {
                    //Блядь чистим изменненые к хуям.
                    var changed = await sqlRChangedInspections.ByPlanedInspectionRouteId(planedInspection.Id);

                    if (changed != null)
                    {
                        await sqlRChangedInspections.Delete(changed.Id);
                    }
                    await sqlRPlanedInspectionOnRoutes.Delete(planedInspection.Id);
                }

                //Ебаем юзеров к хуям
                var planeBrigades = await sqlRPlaneBrigades.ByPlanedRouteTrainId(planedRouteTrainsId);

                foreach (var planeBrigade in planeBrigades)
                {
                    //Блядь чистим изменненые к хуям.
                    var changed = await sqlRChangedBrigades.ByPlaneBrigadeTrainId(planeBrigade.Id);

                    if (changed != null)
                    {
                        await sqlRChangedBrigades.Delete(changed.Id);
                    }
                    await sqlRPlaneBrigades.Delete(planeBrigade.Id);
                }

                //ебаем станки
                var planeStations = await sqlRPlaneStations.ByPlannedRouteTrainId(planedRouteTrainsId);

                foreach (var planeStation in planeStations)
                {
                    //Блядь чистим изменненые к хуям.
                    var changed = await sqlRChangedStations.ByPlaneStantionOnTripId(planeStation.Id);

                    if (changed != null)
                    {
                        await sqlRChangedStations.Delete(changed.Id);
                    }
                    await sqlRPlaneStations.Delete(planeStation.Id);
                }


                //Ну и главную хуету нахуй
                await sqlRPlanedRouteTrains.Delete(planedRouteTrainsId);

                transaction.Complete();
            }
        }
        public async Task <PlanedRouteTrain> AddTrainToPlanedRouteTrains(PlanedRouteTrain input)
        {
            using (var transaction = new TransactionScope(asyncFlowOption: TransactionScopeAsyncFlowOption.Enabled))
            {
                var sqlRTrips                    = new TripsRepository(_logger);
                var sqlRStations                 = new StantionOnTripsRepository(_logger);
                var sqlRInspectionOnRoutes       = new InspectionRoutesRepository(_logger);
                var sqlRPlanedInspectionOnRoutes = new PlanedInspectionRoutesRepository(_logger);

                var sqlRPlaneStations     = new PlanedStationOnTripsRepository(_logger);
                var sqlRPlanedRouteTrains = new PlanedRouteTrainsRepository(_logger);

                //Валидация Хуяция.
                //TODO поменять на sql
                var trainPlaneRoutes = await sqlRPlanedRouteTrains.ByTrainId(input.TrainId);

                if (trainPlaneRoutes.Any(x => x.Date.Date.Equals(input.Date.Date)))
                {
                    throw new ValidationException(Error.AlreadyAdd);
                }

                var result = await sqlRPlanedRouteTrains.Add(input);

                var trips = await sqlRTrips.GetTripsByRouteId(input.RouteId);

                //var tripsStationsDictionary = new Dictionary<Trip, List<StantionOnTrip>>();
                foreach (var trip in trips)
                {
                    var stations = await sqlRStations.ByTripId(trip.Id);

                    foreach (var station in stations)
                    {
                        var toAdd = _mapper.Map <StantionOnTrip, PlaneStantionOnTrip>(station);
                        toAdd.PlanedRouteTrainId = result.Id;
                        var newInTime = toAdd.InTime - DateTime.MinValue;
                        toAdd.InTime = input.Date.Date.Add(newInTime);

                        var newOutTime = toAdd.OutTime - DateTime.MinValue;
                        toAdd.OutTime = input.Date.Date.Add(newOutTime);

                        await sqlRPlaneStations.Add(toAdd);
                    }

                    //tripsStationsDictionary.Add(trip, stations);
                }

                //И тут я узнал что надо инспекции скопировать ебать их в рот
                var inspections = await sqlRInspectionOnRoutes.GetByRouteId(input.RouteId);

                foreach (var inspection in inspections)
                {
                    var toAdd = new PlanedInspectionRoute
                    {
                        CheckListType      = inspection.CheckListType,
                        PlanedRouteTrainId = result.Id,
                    };
                    var newInTime = inspection.Start - inspection.Start.Date;
                    toAdd.Start = input.Date.Date.Add(newInTime);
                    var newOutTime = inspection.End - inspection.End.Date;
                    toAdd.End = input.Date.Date.Add(newOutTime);
                    await sqlRPlanedInspectionOnRoutes.Add(toAdd);
                }


                transaction.Complete();
                return(result);
            }
        }