/// <summary> /// Starts operation process. /// </summary> /// <param name="args">Operation args.</param> /// <exception cref="Exception">Throws if any unhandles exception occurs in method.</exception> protected override void _Execute(params object[] args) { try { // Get current schedule. if (_schedulePage == null) { _schedulePage = (OptimizeAndEditPage)App.Current.MainWindow.GetPage(PagePaths.SchedulePagePath); } Schedule schedule = _schedulePage.CurrentSchedule; ICollection <Order> selectedOrders = _GetOrdersWhichCanBeUnassignedFromSelection(_schedulePage.SelectedItems); ICollection <Order> orders = RoutingCmdHelpers.GetOrdersIncludingPairs(schedule, selectedOrders); ICollection <Route> routes = ViolationsHelper.GetRouteForUnassignOrders(schedule, orders); if (_CheckRoutingParams(schedule, routes, orders)) { SolveOptions options = new SolveOptions(); options.GenerateDirections = App.Current.MapDisplay.TrueRoute; options.FailOnInvalidOrderGeoLocation = false; _SetOperationStartedStatus((string)App.Current.FindResource(UNASSIGN_ORDERS), (DateTime)schedule.PlannedDate); OperationsIds.Add(App.Current.Solver.UnassignOrdersAsync(schedule, orders, options)); // set solve started message string infoMessage = RoutingMessagesHelper.GetUnassignOperationStartedMessage(orders); if (!string.IsNullOrEmpty(infoMessage)) { App.Current.Messenger.AddInfo(infoMessage); } } } catch (RouteException e) { if (e.InvalidObjects != null) // if exception throw because any Routes or Orders are invalid { _ShowSolveValidationResult(e.InvalidObjects); } else { _ShowErrorMsg(RoutingCmdHelpers.FormatRoutingExceptionMsg(e)); } } catch (Exception e) { Logger.Error(e); if ((e is LicenseException) || (e is AuthenticationException) || (e is CommunicationException)) { CommonHelpers.AddRoutingErrorMessage(e); } else { throw; } } }
/// <summary> /// Method unassignes orders from schedule /// </summary> /// <param name="orders"></param> /// <param name="schedule"></param> private void _UnassignOrdersFromSchedule(Schedule schedule, ICollection <Order> orders) { try { ICollection <Order> ordersWithPairs = RoutingCmdHelpers.GetOrdersIncludingPairs(schedule, orders); // Create routes collection. ICollection <Route> routes = ViolationsHelper.GetRouteForUnassignOrders(schedule, ordersWithPairs); if (_CheckRoutingParams(schedule, ordersWithPairs, routes)) { SolveOptions options = new SolveOptions(); options.GenerateDirections = App.Current.MapDisplay.TrueRoute; options.FailOnInvalidOrderGeoLocation = false; string infoMessage = _FormatSuccessUnassigningStartedMessage(schedule, _schedulesToUnassign); // Set operation info status. _SetOperationStartedStatus(infoMessage, (DateTime)schedule.PlannedDate); // Start solve operation. App.Current.Solver.UnassignOrdersAsync(schedule, ordersWithPairs, options); } else // If routing operation was not started - clean collections and unlock UI. { _CleanUp(); _UnlockUI(); } } catch (RouteException e) { App.Current.Messenger.AddError(RoutingCmdHelpers.FormatRoutingExceptionMsg(e)); App.Current.Messenger.AddError(string.Format(OperationIsFailedMessage, schedule)); // Save already edited schedules. _UpdateOptimizeAndEditPageSchedules(); _CleanUp(); _UnlockUI(); } catch (Exception ex) { // Save already edited schedules. _UpdateOptimizeAndEditPageSchedules(); _CleanUp(); _UnlockUI(); if ((ex is LicenseException) || (ex is AuthenticationException) || (ex is CommunicationException)) { CommonHelpers.AddRoutingErrorMessage(ex); } else { throw; } } }
/// <summary> /// Starts operation process. /// </summary> /// <param name="args">Command args. Empty there.</param> protected override void _Execute(params object[] args) { // Create command parameters. OptimizeAndEditPage schedulePage = (OptimizeAndEditPage)App.Current.MainWindow.GetPage(PagePaths.SchedulePagePath); Schedule schedule = schedulePage.CurrentSchedule; ICollection<Route> targetRoutes = ViolationsHelper.GetBuildRoutes(schedule); // And pass they to call _Execute from base class. base._Execute(targetRoutes, (string)App.Current.FindResource(BEST_ROUTE_OPTION_RESOURCE)); }
public static ICollection <Route> GetRoutingCommandRoutes(Schedule schedule, AsyncOperationInfo info) { ICollection <Route> routes = null; switch (info.OperationType) { case SolveOperationType.BuildRoutes: routes = GetBuildRoutes(schedule); break; case SolveOperationType.SequenceRoutes: { Debug.Assert(null != info.InputParams); SequenceRoutesParams param = info.InputParams as SequenceRoutesParams; routes = param.RoutesToSequence; break; } case SolveOperationType.UnassignOrders: { UnassignOrdersParams param = info.InputParams as UnassignOrdersParams; routes = ViolationsHelper.GetRouteForUnassignOrders(schedule, param.OrdersToUnassign); break; } case SolveOperationType.AssignOrders: { AssignOrdersParams param = info.InputParams as AssignOrdersParams; routes = param.TargetRoutes; break; } case SolveOperationType.GenerateDirections: { GenDirectionsParams param = info.InputParams as GenDirectionsParams; routes = param.Routes; break; } default: Debug.Assert(false); // NOTE: not supported break; } return(routes); }
/// <summary> /// Creates violation message for related object collection. /// </summary> /// <param name="obj">Violation's object (can be any DataObject: Vehicle, Driver and etc).</param> /// <param name="relatedObjects">Related object's.</param> /// <param name="resourceStringName">Description message format resource name.</param> /// <returns>Created message detail.</returns> private static MessageDetail _GetRouteViolationMessageStr(DataObject obj, ICollection <DataObject> relatedObjects, string resourceStringName) { Debug.Assert(obj is Route); int paramCount = 1 + relatedObjects.Count; // route + all objects DataObject[] param = new DataObject[paramCount]; int index = 0; string substitution = "{" + index.ToString() + "}"; param[index++] = obj; string relatedObjFormat = ViolationsHelper.GetObjectListFormat(relatedObjects, ref index, param); string format = App.Current.GetString(resourceStringName, substitution, relatedObjFormat); return(new MessageDetail(MessageType.Error, format, param)); }
/// <summary> /// Creates violation message for related object collection. /// </summary> /// <param name="obj">Violation's object (can be any DataObject: Vehicle, Driver and etc).</param> /// <param name="inputCollectionCount">Collection's object count.</param> /// <param name="violatedObjCollection">Violated object collection.</param> /// <param name="formatSingle">Description message format for single object.</param> /// <param name="formatList">Description message format for object's name list.</param> /// <param name="formatAll">Description message format for all object's.</param> /// <returns>Created message detail.</returns> private static MessageDetail _GetViolationMessageStr <T>(DataObject obj, int inputCollectionCount, ICollection <T> violatedObjCollection, string formatSingle, string formatList, string formatAll) where T : DataObject { bool checkOneRoute = (1 == violatedObjCollection.Count); bool checkNotAll = checkOneRoute ? false : (violatedObjCollection.Count < inputCollectionCount); int paramCount = 1; if (checkOneRoute) { ++paramCount; } else if (checkNotAll) { paramCount += violatedObjCollection.Count; } DataObject[] param = new DataObject[paramCount]; string format = null; int index = 0; if (checkOneRoute) { param[index++] = violatedObjCollection.First(); format = formatSingle; } else if (checkNotAll) { string listFormat = ViolationsHelper.GetObjectListFormat(violatedObjCollection, ref index, param); string substitution = "{" + index.ToString() + "}"; format = string.Format(formatList, listFormat, substitution); } else { format = formatAll; } param[index++] = obj; return(new MessageDetail(MessageType.Warning, format, param)); }
/// <summary> /// Method returns collection of violation message details. /// </summary> /// <param name="schedule">Schedule to be checked.</param> /// <param name="info">Solver's asyncrone operation info.</param> /// <param name="violations">Founded violations.</param> /// <returns>Message detail with description for violations.</returns> public static ICollection <MessageDetail> GetViolationDetails(Schedule schedule, AsyncOperationInfo info, ICollection <Violation> violations) { Debug.Assert(null != schedule); Debug.Assert(0 < violations.Count); // special case bool isSpecialCase = false; Order orderToAssign = null; if (SolveOperationType.AssignOrders == info.OperationType) { AssignOrdersParams param = (AssignOrdersParams)info.InputParams; if (null != param.TargetSequence) { isSpecialCase = param.TargetSequence.HasValue; } if (isSpecialCase) { Debug.Assert(1 == param.OrdersToAssign.Count); orderToAssign = param.OrdersToAssign.First(); } } ICollection <MessageDetail> details = null; if (!isSpecialCase && _IsRouteRelatedViolationPresent(violations)) { details = _GetRouteViolationDetails(violations); } else { ICollection <Route> routes = ViolationsHelper.GetRoutingCommandRoutes(schedule, info); Debug.Assert((null != routes) && (0 < routes.Count)); details = _GetViolationDetails(routes, isSpecialCase, orderToAssign, violations); } return(details); }
/// <summary> /// Gets build routes operation parameters for the specified schedule. /// </summary> /// <param name="schedule">The schedule to get build routes operation /// parameters for.</param> /// <returns>Build routes operation parameters.</returns> private BuildRoutesParameters _GetBuildRoutesParameters(Schedule schedule) { var routes = ViolationsHelper.GetBuildRoutes(schedule); // get orders planned on schedule's date var day = (DateTime)schedule.PlannedDate; var orders = from order in App.Current.Project.Orders.Search(day) where !ConstraintViolationsChecker.IsOrderRouteLocked(order, schedule) select order; var parameters = new BuildRoutesParameters() { TargetRoutes = routes, OrdersToAssign = orders.ToList() }; return(parameters); }
private static List <MessageDetail> _CheckDriverSpecialties(ICollection <Route> routes, ICollection <Order> orders) { List <MessageDetail> details = new List <MessageDetail>(); bool checkOneRoute = (1 == routes.Count); string format = App.Current.FindString((checkOneRoute)? "ConstraintsCheckerDriverSpecRouteMessageFmt" : "ConstraintsCheckerDriverSpecRoutesMessageFmt"); foreach (Order order in orders) { ICollection <DriverSpecialty> specialties = (checkOneRoute)? _CanAccommodateOrderSpecialties(routes.First().Driver.Specialties, order.DriverSpecialties) : _CanAccommodateOrderDriverSpecialties(routes, order);; if (null != specialties) { int paramCount = 1 + specialties.Count; if (checkOneRoute) { ++paramCount; } AppData.DataObject[] param = new AppData.DataObject[paramCount]; int index = 0; if (checkOneRoute) { param[index++] = routes.First().Driver; } param[index++] = order; string specialtiesFormat = ViolationsHelper.GetObjectListFormat(specialties, ref index, param); string messageFormat = (checkOneRoute) ? string.Format(format, "{0}", "{1}", specialtiesFormat) : string.Format(format, "{0}", specialtiesFormat); details.Add(new MessageDetail(MessageType.Warning, messageFormat, param)); } } return(details); }
/// <summary> /// Method starts unassigning orders. /// </summary> /// <param name="ordersToAssign">Collection of orders to unassign.</param> private void _UnassignOrders(Collection <Order> ordersToUnassign) { // Get current schedule. OptimizeAndEditPage schedulePage = (OptimizeAndEditPage)(App.Current.MainWindow).GetPage(PagePaths.SchedulePagePath); Schedule schedule = schedulePage.CurrentSchedule; // Remove unassigned orders from collection of orders to unassign. _RemoveUnassignedOrders(ref ordersToUnassign, schedule); // If all orders in selection are unassigned - just return. if (ordersToUnassign.Count == 0) { return; } ICollection <Route> routes = ViolationsHelper.GetRouteForUnassignOrders(schedule, ordersToUnassign); if (_CheckRoutingParams(schedule, routes, ordersToUnassign)) { SolveOptions options = new SolveOptions(); options.GenerateDirections = App.Current.MapDisplay.TrueRoute; options.FailOnInvalidOrderGeoLocation = false; // Update status. _SetOperationStartedStatus((string)App.Current.FindResource(UNASSIGN_ORDERS), (DateTime)schedule.PlannedDate); // Start solve. OperationsIds.Add(App.Current.Solver.UnassignOrdersAsync(schedule, ordersToUnassign, options)); // Set solve started message string infoMessage = RoutingMessagesHelper.GetUnassignOperationStartedMessage(ordersToUnassign); if (!string.IsNullOrEmpty(infoMessage)) { App.Current.Messenger.AddInfo(infoMessage); } } }