Beispiel #1
0
        public async Task UpdateAsync(RouteBase routeBaseUpdate)
        {
            // Error if route base does not exist
            var routeBase = await ValidateRouteBaseExistsAsync(routeBaseUpdate.Id);

            var routeBaseControl = routeBase;

            // Error if origin and destination are the same point
            PointsValidation.ValidateEqualPointsAsync(routeBaseUpdate.Origin?.Description, routeBaseUpdate.Destination?.Description);

            if (!string.IsNullOrWhiteSpace(routeBaseUpdate.Origin?.Description))
            {
                // Error if point description does not exist
                var origin = await PointsValidation.ValidatePointExistsAsync(_pointRepository, routeBaseUpdate.Origin.Description);

                routeBase.Origin = origin;
            }

            if (!string.IsNullOrWhiteSpace(routeBaseUpdate.Destination?.Description))
            {
                // Error if point description does not exist
                var destination = await PointsValidation.ValidatePointExistsAsync(_pointRepository, routeBaseUpdate.Destination.Description);

                routeBase.Destination = destination;
            }

            // Error if route base with such points already exists
            await ValidateRouteBaseAlreadyExistsAsync(routeBase);

            await _routeBaseRepository.UpdateAsync(routeBase);

            RemoveDependentObjectsFromCache(routeBaseControl);
        }
Beispiel #2
0
        public async Task <RouteBase> CreateAsync(RouteBase routeBase)
        {
            // Error if origin and destination are the same point
            PointsValidation.ValidateEqualPointsAsync(routeBase.Origin?.Description, routeBase.Destination?.Description);

            // Error if point description does not exist
            var origin = await PointsValidation.ValidatePointExistsAsync(_pointRepository, routeBase.Origin?.Description);

            var destination = await PointsValidation.ValidatePointExistsAsync(_pointRepository, routeBase.Destination?.Description);

            var routeBaseToAdd = new RouteBase
            {
                Origin      = origin,
                Destination = destination
            };

            // Error if route base with such points already exists
            await ValidateRouteBaseAlreadyExistsAsync(routeBaseToAdd);

            await _routeBaseRepository.AddAsync(routeBaseToAdd);

            var routeBases = await _routeBaseRepository.GetAsync();

            var routeReturn = routeBases.FirstOrDefault(x =>
                                                        (x.Origin?.Description?.Equals(routeBaseToAdd.Origin.Description) == true || x.OriginId == routeBaseToAdd.OriginId) &&
                                                        (x.Destination?.Description?.Equals(routeBaseToAdd.Destination.Description) == true || x.DestinationId == routeBaseToAdd.DestinationId));

            return(routeReturn);
        }
Beispiel #3
0
        public async Task <Step> CreateAsync(Step step)
        {
            // Error if start and end are the same point
            PointsValidation.ValidateEqualPointsAsync(step.Start?.Description, step.End?.Description);

            // Error if point description does not exist
            var start = await PointsValidation.ValidatePointExistsAsync(_pointRepository, step.Start?.Description);

            var end = await PointsValidation.ValidatePointExistsAsync(_pointRepository, step.End?.Description);

            var stepToAdd = new Step
            {
                Start = start,
                End   = end
            };

            // Error if step with such points already exists
            await ValidateStepAlreadyExistsAsync(stepToAdd);

            // Error if time/cost is zero or less
            ValidatePositiveTimeCost(step.Cost);
            ValidatePositiveTimeCost(step.Time);

            stepToAdd.Cost = step.Cost;
            stepToAdd.Time = step.Time;

            await _stepRepository.AddAsync(stepToAdd);

            _cacheManager.RemoveBulkWithExpression(CacheKeys.Route);

            return((await _stepRepository.GetAsync()).FirstOrDefault(x =>
                                                                     (x.Start?.Description?.Equals(stepToAdd.Start.Description) == true || x.StartId == stepToAdd.Start.Id) &&
                                                                     (x.End?.Description?.Equals(stepToAdd.End.Description) == true || x.EndId == stepToAdd.End.Id)));
        }
Beispiel #4
0
        /// <summary>Calculates a route base for a given origin and destination.</summary>
        /// <param name="originPoint">The origin point.</param>
        /// <param name="destinationPoint">The destination point.</param>
        /// <returns>The route base.</returns>
        private async Task <RouteBase> CalculateRouteBaseAsync(string originPoint, string destinationPoint)
        {
            // Error if origin and destination are the same point
            PointsValidation.ValidateEqualPointsAsync(originPoint, destinationPoint);

            // Error if point description does not exist
            var origin = await PointsValidation.ValidatePointExistsAsync(_pointRepository, originPoint);

            var destination = await PointsValidation.ValidatePointExistsAsync(_pointRepository, destinationPoint);

            var routeBase = new RouteBase
            {
                Origin      = origin,
                Destination = destination
            };

            // Error if route base with such points does not exist
            await ValidateRouteBaseExistsAsync(routeBase);

            // Error if there is not any step to begin the route, or if there is not any step to finish the route
            await ValidateStepStartExistsAsync(origin);
            await ValidateStepEndExistsAsync(destination);

            return(routeBase);
        }
Beispiel #5
0
        public async Task UpdateAsync(Step stepUpdate)
        {
            var step = await ValidateStepExistsAsync(stepUpdate.Id);

            // Error if start and end are the same point
            PointsValidation.ValidateEqualPointsAsync(stepUpdate.Start?.Description, stepUpdate.End?.Description);

            if (!string.IsNullOrWhiteSpace(stepUpdate.Start?.Description))
            {
                // Error if point description does not exist
                var start = await PointsValidation.ValidatePointExistsAsync(_pointRepository, stepUpdate.Start.Description);

                step.Start = start;
            }

            if (!string.IsNullOrWhiteSpace(stepUpdate.End?.Description))
            {
                // Error if point description does not exist
                var end = await PointsValidation.ValidatePointExistsAsync(_pointRepository, stepUpdate.End.Description);

                step.End = end;
            }

            // Error if step with such points already exists
            await ValidateStepAlreadyExistsAsync(step);

            if (stepUpdate.Cost > 0)
            {
                step.Cost = stepUpdate.Cost;
            }
            if (stepUpdate.Time > 0)
            {
                step.Time = stepUpdate.Time;
            }

            await _stepRepository.UpdateAsync(step);

            _cacheManager.RemoveBulkWithExpression(CacheKeys.Route);
        }