Exemplo n.º 1
0
        public async Task Delete(int id)
        {
            await CheckPermission();

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

            var sqlR   = new ChangePlaneStantionOnTripsRepository(_logger);
            var result = await sqlR.GetAll(skip, limit, filter);

            return(Json(result));
        }
Exemplo n.º 3
0
        /// <summary>
        /// Данные по станкам
        /// </summary>
        private static async Task GetPlaneStationsData(RouteData result, List <PlaneStantionOnTrip> planeStations,
                                                       int tripId, ILogger logger)
        {
            var sqlRStations          = new StantionsRepository(logger);
            var sqlRTrips             = new TripsRepository(logger);
            var sqlRTrains            = new TrainRepository(logger);
            var sqlRChangedStantion   = new ChangePlaneStantionOnTripsRepository(logger);
            var sqlRPlanedRouteTrains = new PlanedRouteTrainsRepository(logger);

            var planedTripWithStation = new PlanedTripWithStations
            {
                TripName      = (await sqlRTrips.ById(tripId)).Name,
                PlaneStations = new List <PlanedStation>()
            };

            var currentTripPlaneStations = planeStations.Where(x => x.TripId == tripId);

            foreach (var currentTripPlaneStation in currentTripPlaneStations)
            {
                var changedStationData = await sqlRChangedStantion.ByPlaneStantionOnTripId(currentTripPlaneStation.Id);

                var toAdd = new PlanedStation
                {
                    PlanedStationId  = currentTripPlaneStation.Id,
                    StationName      = (await sqlRStations.ById(currentTripPlaneStation.StantionId)).Name,
                    InTime           = currentTripPlaneStation.InTime,
                    OutTime          = currentTripPlaneStation.OutTime,
                    ChangeStationsId = changedStationData?.Id,
                    ChangedInTime    = changedStationData?.InTime,
                    ChangedOutTime   = changedStationData?.OutTime,
                    ChangeDroped     = changedStationData?.Droped,
                    ChangeTrainId    = changedStationData?.TrainId
                };

                //TODO надо уточнить стоит ли так делать. Возвращать нулл если поезд нихуя непоменялся
                var planedRouteTrain = await sqlRPlanedRouteTrains.ById(currentTripPlaneStation.PlanedRouteTrainId);

                if (planedRouteTrain.TrainId == toAdd.ChangeTrainId)
                {
                    toAdd.ChangeTrainId = null;
                }

                if (toAdd.ChangeTrainId != null)
                {
                    toAdd.ChangeTranName = (await sqlRTrains.ById(toAdd.ChangeTrainId)).Name;
                }

                planedTripWithStation.PlaneStations.Add(toAdd);
            }

            result.PlaneRoute.TripsWithStations.Add(planedTripWithStation);
        }
Exemplo n.º 4
0
        public async Task <JsonResult> AddOrUpdate([FromBody] ChangePlaneStantionOnTrip input)
        {
            await CheckPermission();

            if (input.InTime >= input.OutTime)
            {
                throw new ValidationException("Время начала, больше времени конца");
            }
            var sqlR = new ChangePlaneStantionOnTripsRepository(_logger);

            if (input.Id == 0)
            {
                return(Json(await sqlR.Add(input)));
            }
            return(Json(await sqlR.Update(input)));
        }
Exemplo n.º 5
0
        /// <summary>
        ///  Рейсы со станками таблица
        /// </summary>
        private static async Task <RouteInformationTableTrip> GetTripData(GetRouteInformationTableRequest input, ILogger logger)
        {
            var sqlRStations           = new StantionsRepository(logger);
            var sqlRTrips              = new TripsRepository(logger);
            var sqlRTrains             = new TrainRepository(logger);
            var sqlRChangedStation     = new ChangePlaneStantionOnTripsRepository(logger);
            var sqlRPlannedRouteTrains = new PlanedRouteTrainsRepository(logger);
            var sqlRPlannedStations    = new PlanedStationOnTripsRepository(logger);

            var result = new RouteInformationTableTrip
            {
                Stantions  = new List <RouteInformationTableStantion>(),
                DataSource = new DataSource()
            };

            var plannedRouteTrain = await sqlRPlannedRouteTrains.ById(input.PlanedRouteTrainId);

            var plannedStations = await sqlRPlannedStations.ByPlannedRouteTrainId(input.PlanedRouteTrainId);

            var tripId = plannedStations.Where(x => x.TripId == input.EntityId).Select(x => x.TripId).ToList();

            if (!tripId.Any())
            {
                return(result);
            }

            var trip = await sqlRTrips.ById(tripId.First());

            result.Trip = trip.Name;
            var currentTripPlaneStations = plannedStations.Where(x => x.TripId == trip.Id);

            foreach (var currentTripPlaneStation in currentTripPlaneStations)
            {
                var planTrain = await sqlRTrains.ById(plannedRouteTrain.TrainId);

                var changedStationData =
                    await sqlRChangedStation.ByPlaneStantionOnTripId(currentTripPlaneStation.Id);

                //String changedTrainName;
                //if (changedStationData?.TrainId != null)
                //    changedTrainName = (await sqlRTrains.ById(changedStationData.TrainId)).Name;

                var toAdd = new RouteInformationTableStantion
                {
                    Id                   = currentTripPlaneStation.Id,
                    Name                 = (await sqlRStations.ById(currentTripPlaneStation.StantionId)).Name,
                    Train                = planTrain.Name,
                    StartPlan            = currentTripPlaneStation.InTime.ToStringTimeOnly(),
                    EndPlan              = currentTripPlaneStation.OutTime.ToStringTimeOnly(),
                    TrainId              = planTrain.Id,
                    StartFact            = currentTripPlaneStation.InTime.ToFuckingGenaFormat(plannedRouteTrain.Date.Date),
                    EndFact              = currentTripPlaneStation.OutTime.ToFuckingGenaFormat(plannedRouteTrain.Date.Date),
                    Canceled             = false,
                    PlaneStationOnTripId = currentTripPlaneStation.Id
                };

                if (changedStationData != null)
                {
                    toAdd.StartFact = changedStationData.InTime.ToFuckingGenaFormat(plannedRouteTrain.Date.Date);
                    toAdd.EndFact   = changedStationData.OutTime.ToFuckingGenaFormat(plannedRouteTrain.Date.Date);
                    toAdd.Canceled  = changedStationData.Droped;
                    if (changedStationData.TrainId != null)
                    {
                        toAdd.TrainId = (int)changedStationData.TrainId;
                    }
                }
                result.Stantions.Add(toAdd);
            }

            var availableTrains = await GetAvaibleTrains(plannedRouteTrain.TrainId, logger);

            result.DataSource.Trains =
                availableTrains.Select(x => new DataSourceDto {
                Value = x.TrainId, Text = x.TrainName
            }).ToList();

            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();
            }
        }