Пример #1
0
        public BaseResult MergeRouteLocation(RouteLocationVM routeLocationVM, int?nextRouteLocationId)
        {
            var result = new BaseResult();

            try
            {
                var nextVM = GetRouteLocation(routeLocationVM.RouteId, nextRouteLocationId).Data;
                if (nextVM != null)
                {
                    nextVM.PreviousLocationId = routeLocationVM.CurrentLocationId;
                    var next = Mapper.Map <RouteLocation>(nextVM);
                    UnitOfWork.RouteLocationDao.Update(next);
                }

                var routeLocation = Mapper.Map <RouteLocation>(routeLocationVM);
                UnitOfWork.RouteLocationDao.Merge(routeLocation);

                result.Success = true;
                result.Message = GeneralSuccessMessage;
            }
            catch (Exception ex)
            {
                result.Success = false;
                result.Message = GeneralErrorMessage;
            }
            return(result);
        }
Пример #2
0
        public async Task <IActionResult> InsertLocationToRoute(int routeId, int routeLocationId, int locationToAddId, MergeRouteLocationMode mode)
        {
            var result = new Result <IEnumerable <RouteLocationVM> >();

            try
            {
                var route              = ServiceFactory.RouteManagement.GetRoute(routeId).Data;
                var routeLocations     = ServiceFactory.RouteManagement.GetRouteLocations(route.Id).Data;
                var firstRouteLocation = routeLocations.First();

                var routeLocationIds = routeLocations.Select(x => x.CurrentLocationId).ToList();
                var index            = routeLocationIds.FindIndex(x => x == routeLocationId);
                if (mode == MergeRouteLocationMode.Prepend)
                {
                    index++;
                }
                routeLocationIds.Insert(index, locationToAddId);

                var routeLocationList  = new List <RouteLocationVM>();
                var previousLocationId = (int?)null;
                foreach (var id in routeLocationIds)
                {
                    var routeLocation = new RouteLocationVM
                    {
                        CurrentLocationId = id
                    };
                    if (previousLocationId.HasValue)
                    {
                        var distance = await GetOrGenerateDistance(previousLocationId.Value, id);

                        routeLocation.Distance   = distance.TomTomLeg.Summary.LengthInMeters / (double)1000;
                        routeLocation.TomTomInfo = distance.TomTomInfo;
                    }
                    else
                    {
                        routeLocation.CurrentLatitude  = firstRouteLocation.CurrentLatitude;
                        routeLocation.CurrentLongitude = firstRouteLocation.CurrentLongitude;
                    }

                    routeLocationList.Add(routeLocation);
                    previousLocationId = id;
                }

                result.Data    = routeLocationList;
                result.Message = "Успешно добавлена новая локация!";
                result.Success = true;
            }
            catch (Exception ex)
            {
                result.Data    = null;
                result.Success = false;
            }

            return(Json(result));
        }
Пример #3
0
        public IActionResult MergeRouteLocation(MergeRouteLocationVM mergeRouteLocationVM)
        {
            var result = new Result();

            try
            {
                var routeLocations       = ServiceFactory.RouteManagement.GetRouteLocations(mergeRouteLocationVM.RouteId).Data;
                var currentRouteLocation = routeLocations.FirstOrDefault(x => x.CurrentLocationId == mergeRouteLocationVM.RouteLocationId);

                var locationToAdd = new RouteLocationVM
                {
                    RouteId           = mergeRouteLocationVM.RouteId,
                    CurrentLocationId = mergeRouteLocationVM.LocationToAddId
                };
                var nextId = (int?)null;

                if (mergeRouteLocationVM.Mode == MergeRouteLocationMode.Append)
                {
                    var previous = routeLocations.FirstOrDefault(x => x.CurrentLocationId == currentRouteLocation.PreviousLocationId);
                    locationToAdd.PreviousLocationId = previous?.CurrentLocationId;
                    nextId = currentRouteLocation.CurrentLocationId;
                }
                else if (mergeRouteLocationVM.Mode == MergeRouteLocationMode.Prepend)
                {
                    var next = routeLocations.FirstOrDefault(x => x.PreviousLocationId == currentRouteLocation.CurrentLocationId);
                    locationToAdd.PreviousLocationId = currentRouteLocation.CurrentLocationId;
                    nextId = next?.CurrentLocationId;
                }

                var serviceResult = ServiceFactory.RouteManagement.MergeRouteLocation(locationToAdd, nextId);
                ServiceFactory.ScheduleManagement.UpdateNeedsSyncStatusByRouteId(locationToAdd.RouteId);

                result.Success = serviceResult.Success;
                result.Message = serviceResult.Message;
            }
            catch (Exception ex)
            {
                result.Success = false;
            }
            return(Json(result));
        }