/// <summary>
/// Define whether option is enabled.
/// </summary>
protected override void _CheckEnabled(OptimizeAndEditPage schedulePage)
{
Debug.Assert(schedulePage != null);
if (schedulePage.CurrentSchedule == null)
{
this.IsEnabled = false;
return;
}
bool result = false;
// If all routes locked - option should be disabled.
foreach (Route route in schedulePage.CurrentSchedule.Routes)
{
if (!route.IsLocked)
{
result = true;
break;
}
}
IsEnabled = result;
}
/// <summary>
/// Method finds all routes what not in current routes and satisfies current day
/// </summary>
private void _MakeAvailableRoutes()
{
_availableRoutes.Clear();
Schedule currentSchedule = null;
OptimizeAndEditPage _schedulePage = (OptimizeAndEditPage)(((MainWindow)App.Current.MainWindow).GetPage(PagePaths.SchedulePagePath));
currentSchedule = _schedulePage.CurrentSchedule;
if (currentSchedule != null)
{
_currentRoutes = currentSchedule.Routes;
if (_currentRoutes != null && DefaultRoutes != null)
{
foreach (Route defaultRoute in DefaultRoutes)
{
if (!_IsRouteFound(_currentRoutes, defaultRoute))
{
Route newRoute = (Route)defaultRoute.Clone();
_availableRoutes.Add(newRoute);
}
}
}
}
_ComboBox.ItemsSource = null;
_ComboBox.Items.Clear();
_ComboBox.ItemsSource = _availableRoutes;
}
/// <summary>
/// Creates instance of ScheduleViewsEditingManager, initializes local field _multipleListViewManager
/// and adds handler to ListViewsCollectionChanged event.
/// </summary>
/// <param name="optimizeAndEditPage">OptimizeAndEditPage.</param>
public ScheduleViewsEditingManager(OptimizeAndEditPage optimizeAndEditPage)
{
_ordersView = optimizeAndEditPage.OrdersView;
_AddEditingEventHandlers(_ordersView);
_routesView = optimizeAndEditPage.RoutesView;
_AddEditingEventHandlers(_routesView);
}
/// <summary>
/// Starts option process.
/// </summary>
/// <param name="args">Operation args. Empty there.</param>
protected override void _Execute(params object[] args)
{
OptimizeAndEditPage schedulePage = (OptimizeAndEditPage)App.Current.MainWindow.GetPage(PagePaths.SchedulePagePath);
Schedule schedule = schedulePage.CurrentSchedule;
ICollection <Route> targetRoutes = _GetOtherRoutes(schedule, schedulePage.SelectedItems);
base._Execute(targetRoutes, (string)App.Current.FindResource(BEST_OTHER_ROUTE));
}
/// <summary>
/// Initializes a new instance.
/// </summary>
/// <param name="parentPage">Parent page.</param>
public OrdersViewContextHandler(OptimizeAndEditPage parentPage)
{
Debug.Assert(null != parentPage);
_parentPage = parentPage;
_currentSchedule = parentPage.CurrentSchedule;
_geocodablePage = parentPage.GeocodablePage;
}
private void App_ApplicationInitialized(object sender, EventArgs e)
{
OptimizeAndEditPage schedulePage = (OptimizeAndEditPage)((MainWindow)App.Current.MainWindow).GetPage(PagePaths.SchedulePagePath);
if (schedulePage != null)
{
schedulePage.CurrentScheduleChanged += new EventHandler(schedulePage_CurrentScheduleChanged);
}
}
/// <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));
}
/// <summary>
/// "Finish" button cliked in page.
/// </summary>
/// <param name="sender">Page when button clicked.</param>
/// <param name="e">Ignored.</param>
protected override void _OnFinishRequired(object sender, EventArgs e)
{
OptimizeAndEditPage optimizePage = _GetOptimizePage();
if (optimizePage.IsAllowed)
{
optimizePage.Loaded += new System.Windows.RoutedEventHandler(_OptimizePageLoaded);
}
// Close wizard.
_Close(optimizePage.IsAllowed ? PagePaths.SchedulePagePath : PagePaths.ProjectsPagePath);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="parentPage">Optimize and edit page.</param>
public RoutesListViewContextHandler(OptimizeAndEditPage parentPage)
{
Debug.Assert(null != parentPage);
Debug.Assert(null != parentPage.CurrentSchedule);
_parentPage = parentPage;
_routes = parentPage.CurrentSchedule.Routes;
_dataGridControl = parentPage.RoutesView.RoutesGrid;
_dataGridControl.InitializingInsertionRow += new EventHandler <InitializingInsertionRowEventArgs>(xceedGrid_InitializingInsertionRow);
_mapControl = parentPage.MapView.mapCtrl;
_mapControl.EndEditRouteCallback = _EditEnded;
}
/// <summary>
/// Method creates collection of already used drivers in other routes
/// </summary>
public static Collection <ESRI.ArcLogistics.Data.DataObject> CreateUsedDriversCollection()
{
OptimizeAndEditPage schedulePage = (OptimizeAndEditPage)((App.Current.MainWindow).GetPage(PagePaths.SchedulePagePath));
Schedule currentSchedule = schedulePage.CurrentSchedule;
ICollection <Route> routeCollection = currentSchedule.Routes;
Collection <ESRI.ArcLogistics.Data.DataObject> usedDrivers = new Collection <ESRI.ArcLogistics.Data.DataObject>();
foreach (Route route in routeCollection)
{
usedDrivers.Add(route.Driver);
}
return(usedDrivers);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="optimizeAndEditPage">Parent page.</param>
/// <param name="timeView">Time view.</param>
public SelectionManager(OptimizeAndEditPage optimizeAndEditPage)
{
_optimizeAndEditPage = optimizeAndEditPage;
_timeView = optimizeAndEditPage.TimeView;
_mapView = optimizeAndEditPage.MapView;
_ordersView = optimizeAndEditPage.OrdersView;
_routesView = optimizeAndEditPage.RoutesView;
// Set callback for checking selection possibility.
_mapView.mapCtrl.CanSelectCallback = _CanSelect;
_CreateCollectionsInMultiCollectionBinding();
_InitEventHandlers();
_selectionChanger = new SelectionChanger(_optimizeAndEditPage);
}
/// <summary>
/// Method reloads all schedules in optimize and edit page
/// </summary>
private void _UpdateOptimizeAndEditPageSchedules()
{
OptimizeAndEditPage page = (OptimizeAndEditPage)((MainWindow)App.Current.MainWindow).GetPage(PagePaths.SchedulePagePath);
page.SetRoutingStatus(string.Empty, App.Current.CurrentDate);
Debug.Assert(page != null);
foreach (UnassignScheduleInfo info in _schedulesToUnassign)
{
// Refresh unassigned orders collection if schedule was changed
if (info.IsProcessed)
{
if (info.Schedule.UnassignedOrders == null)
{
info.Schedule.UnassignedOrders = App.Current.Project.Orders.SearchUnassignedOrders(info.Schedule, true);
}
}
}
}
/// <summary>
/// Adds new routes to current schedule routes.
/// </summary>
private void _UpdateCurrentScheduleRoutes()
{
OptimizeAndEditPage optimizePage = _GetOptimizePage();
Schedule schedule = optimizePage.CurrentSchedule;
if (null != schedule)
{
IDataObjectCollection <Route> wizardRoutes = DataKeeper.Routes;
IDataObjectCollection <Route> scheduleRoutes = schedule.Routes;
for (int index = 0; index < wizardRoutes.Count; ++index)
{
Route route = wizardRoutes[index];
if (!_IsObjectPresentInCollection(route, scheduleRoutes))
{
scheduleRoutes.Add(route);
}
}
}
}
protected override void _Execute(params object[] args)
{
OptimizeAndEditPage schedulePage = (OptimizeAndEditPage)((MainWindow)App.Current.MainWindow).GetPage(PagePaths.SchedulePagePath);
IVrpSolver solver = App.Current.Solver;
Debug.Assert(solver != null);
// get operations for current date
IList <AsyncOperationInfo> currentOperations = solver.GetAsyncOperations(App.Current.CurrentDate);
Debug.Assert(currentOperations != null && currentOperations.Count == 1);
// cancel current operation
bool isEnabled = !solver.CancelAsyncOperation(currentOperations[0].Id);
Debug.Assert(!isEnabled);
// Change status string for current date to "Canceling..." and hide "Cancel" button
schedulePage.SetCancellingStatus(App.Current.CurrentDate);
}
/// <summary>
/// Define whether option is enabled.
/// </summary>
protected override void _CheckEnabled(OptimizeAndEditPage schedulePage)
{
Debug.Assert(schedulePage != null);
// Option is enabled if all selected stops belong to the same route.
if (!_AreAllSelectedOrdersAssignedToOneRoute(schedulePage.SelectedItems))
{
IsEnabled = false;
return;
}
var sourceRoute = _GetSourceRoute(schedulePage.SelectedItems);
var result =
schedulePage.CurrentSchedule != null &&
schedulePage.CurrentSchedule.Routes.Any(
route => !route.IsLocked && route != sourceRoute);
IsEnabled = result;
}
/// <summary>
/// Method starts moving orders.
/// </summary>
/// <param name="ordersToAssign">Collection of orders to move.</param>
/// <param name="targetRoutes">Target routes.</param>
/// <param name="sequence">Order sequence. Can be null.</param>
private void _MoveOrders(Collection <Order> ordersToAssign, ICollection <Route> targetRoutes, int?sequence)
{
_RemoveRedundantOrders(ref ordersToAssign, targetRoutes, sequence);
// if collection of dropping orders is empty - return
if (ordersToAssign.Count == 0)
{
return;
}
// get current schedule
OptimizeAndEditPage schedulePage = (OptimizeAndEditPage)(App.Current.MainWindow).GetPage(PagePaths.SchedulePagePath);
Schedule schedule = schedulePage.CurrentSchedule;
if (_CheckRoutingParams(schedule, targetRoutes, ordersToAssign))
{
SolveOptions options = new SolveOptions();
options.GenerateDirections = App.Current.MapDisplay.TrueRoute;
options.FailOnInvalidOrderGeoLocation = false;
// Update status.
_SetOperationStartedStatus((string)App.Current.FindResource("AssignOrders"), (DateTime)schedule.PlannedDate);
// Start solve.
OperationsIds.Add(App.Current.Solver.AssignOrdersAsync(schedule, ordersToAssign,
targetRoutes, sequence,
false, options));
IEnumerator <Route> rtEnum = targetRoutes.GetEnumerator();
rtEnum.MoveNext();
// Set solve started message.
string infoMessage = RoutingMessagesHelper.GetAssignOperationStartedMessage(
ordersToAssign, rtEnum.Current.Name);
if (!string.IsNullOrEmpty(infoMessage))
{
App.Current.Messenger.AddInfo(infoMessage);
}
}
}
/// <summary>
/// Do routes shapes generation.
/// </summary>
/// <param name="routesWithoutGeometry">Route to generate geometry.</param>
private void _DoGenerateRoutesShapes(List <Route> routesWithoutGeometry)
{
Debug.Assert(routesWithoutGeometry != null);
Debug.Assert(routesWithoutGeometry.Count > 0);
// Set routing status.
Route route = routesWithoutGeometry[0];
DateTime date = route.Schedule.PlannedDate.Value;
OptimizeAndEditPage optimizeAndEditPage = (OptimizeAndEditPage)App.Current.MainWindow.GetPage(PagePaths.SchedulePagePath);
optimizeAndEditPage.SetRoutingStatus((string)App.Current.FindResource("GenerateRouteShapes"), date);
// Add routing message to messenger.
string message = string.Format((string)App.Current.FindResource("GenerateRouteShapesStartText"), date.ToShortDateString());
App.Current.Messenger.AddInfo(message);
// Lock all application UI.
App.Current.UIManager.Lock(true);
// Subscribe to routing command completed.
App.Current.Solver.AsyncSolveCompleted += _AsyncSolveCompleted;
try
{
// Save operation ID.
_operationID = App.Current.Solver.GenerateDirectionsAsync(routesWithoutGeometry);
}
catch (Exception e)
{
App.Current.Solver.AsyncSolveCompleted -= _AsyncSolveCompleted;
Logger.Error(e);
CommonHelpers.AddRoutingErrorMessage(e);
_ReturnUIToDefaultState();
}
}
/// <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);
}
}
}
/// <summary>
///Checks whether option enabled.
/// </summary>
/// <returns></returns>
protected override void _CheckEnabled(OptimizeAndEditPage schedulePage)
{
IsEnabled = !_targetRoute.IsLocked;
}
/// <summary>
/// Saves new schedule if it's build correctly or show error message.
/// </summary>
/// <param name="res">Solve result.</param>
/// <param name="schedule">Schedule.</param>
/// <param name="info">Operation info.</param>
protected void _SaveSchedule(SolveResult res, Schedule schedule, AsyncOperationInfo info)
{
// if solver returns "failed"
if (res.IsFailed)
{
// show result message(s)
string message = string.Format(
(string)App.Current.FindResource(ROUTING_OPERATION_FAILED),
schedule.PlannedDate.Value.ToShortDateString());
ICollection <MessageDetail> details = null;
if (0 < res.Violations.Count)
{
details = ViolationMessageBuilder.GetViolationDetails(schedule, info, res.Violations);
}
// Create details from solver error message.
else
{
details = new Collection <MessageDetail>();
var errorMessage = RoutingCmdHelpers.FormatSolverErrorMsg(res);
// If we have error message - add message detail.
if (errorMessage.Length != 0)
{
details.Add(new MessageDetail(MessageType.Error, errorMessage));
}
}
App.Current.Messenger.AddError(message, details);
}
else
{
// set unassigned orders
if (null != schedule.UnassignedOrders)
{
schedule.UnassignedOrders.Dispose();
}
// save route results
Project project = App.Current.Project;
project.Save();
schedule.UnassignedOrders = project.Orders.SearchUnassignedOrders(schedule, true);
// In case operation is Build Routes we should create "Original Schedule" if doesn't exist yet.
// Schedule must be current.
if (info.OperationType == SolveOperationType.BuildRoutes)
{
if (schedule.Type == ScheduleType.BuildRoutesSnapshot)
{
// update current schedule (according to CR133526)
_UpdateSchedule(ScheduleType.Current, schedule,
(string)App.Current.FindResource("CurrentScheduleName"));
// update build routes snapshot name
schedule.Name = _FormatBuildRoutesSnapshotName();
}
else
{
// update build routes snapshot
_UpdateSchedule(ScheduleType.BuildRoutesSnapshot, schedule, _FormatBuildRoutesSnapshotName());
}
// save changes
project.Save();
}
// Show result message(s).
if (0 < res.Violations.Count)
{
_ShowPartialSuccessOperationResults(res.Violations, schedule, info);
}
else
{
// If operation type is Assign To Routes
// show that Order was assigned to that Route
if (info.OperationType.Equals(SolveOperationType.AssignOrders))
{
_ShowSuccessfullyAssignedOrders(schedule, info);
}
else
{
App.Current.Messenger.AddInfo(
_FormatSuccessSolveCompletedMsg(schedule, info));
}
}
}
OptimizeAndEditPage page = (OptimizeAndEditPage)((MainWindow)App.Current.MainWindow).GetPage(PagePaths.SchedulePagePath);
if (null != page)
{
page.OnScheduleChanged(schedule);
}
}
/// <summary>
/// Sets status to status bar in OptimizeAndEditPage
/// </summary>
/// <param name="statusString"></param>
protected void _SetOperationStartedStatus(string statusString, DateTime date)
{
OptimizeAndEditPage optimizeAndEditPage = (OptimizeAndEditPage)App.Current.MainWindow.GetPage(PagePaths.SchedulePagePath);
optimizeAndEditPage.SetRoutingStatus(statusString, date);
}
/// <summary>
/// Starts command executing.
/// </summary>
/// <param name="args">Command args.</param>
protected override void _Execute(params object[] args)
{
// Get OptimizeAndEdit page.
OptimizeAndEditPage schedulePage = ((MainWindow)App.Current.MainWindow).GetPage(PagePaths.SchedulePagePath) as OptimizeAndEditPage;
Debug.Assert(schedulePage != null);
// If editing is in progress - try to save editing.
if (schedulePage.IsEditingInProgress)
{
// If editing cannot be saved - cancel editing.
if (!schedulePage.SaveEditedItem())
{
schedulePage.CancelObjectEditing();
}
}
// Orders to assign.
Collection <Order> ordersToAssign = (Collection <Order>)args[0];
Debug.Assert(ordersToAssign != null);
// Target object.
Object target = (Object)args[1];
// Include paired orders unless we are moving one order within the same route
bool movingSingleOrderInPair = false;
if (ordersToAssign.Count == 1 && (target is Stop))
{
Route targetRoute = (target as Stop).Route;
Order orderToAssign = ordersToAssign.ElementAt(0);
foreach (Stop stop in targetRoute.Stops)
{
Order associatedOrder = stop.AssociatedObject as Order;
if (associatedOrder == null)
{
continue;
}
if (associatedOrder == orderToAssign)
{
movingSingleOrderInPair = true;
break;
}
}
}
if (!movingSingleOrderInPair)
{
ordersToAssign = RoutingCmdHelpers.GetOrdersIncludingPairs(schedulePage.CurrentSchedule, ordersToAssign) as Collection <Order>;
}
int?sequence = null;
if (target is Stop)
{
// Set sequence only if there is a single order to assign.
if (ordersToAssign.Count == 1)
{
sequence = (target as Stop).SequenceNumber;
}
else // Otherwise change target to route. For more details see CR161083.
{
target = (target as Stop).Route;
}
}
// Get target routes.
ICollection <Route> targetRoutes = _CreateTargetRoutes(target);
try
{
// If target routes count is 0 - orders must be unassigned.
if (targetRoutes.Count == 0)
{
// Start unassigning orders.
_UnassignOrders(ordersToAssign);
}
else
{
// Start moving orders.
_MoveOrders(ordersToAssign, targetRoutes, sequence);
}
}
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>
/// Overrided method for move orders. It will be called in parent class
/// </summary>
/// <param name="args"></param>
protected override void _ProcessOrders(params object[] args)
{
Collection <Order> ordersToAssign = args[0] as Collection <Order>;
DateTime targetDate = (DateTime)args[1];
Debug.Assert(targetDate != null);
Debug.Assert(ordersToAssign != null);
// Include any paired orders
ICollection <Schedule> currentSchedules = App.Current.Project.Schedules.Search(App.Current.CurrentDate);
if (currentSchedules != null && currentSchedules.Count > 0)
{
Schedule schedule = currentSchedules.ElementAt(0);
// Ensure unassigned orders is up to date
schedule.UnassignedOrders = null;
OptimizeAndEditHelpers.FixSchedule(App.Current.Project, schedule);
ordersToAssign = RoutingCmdHelpers.GetOrdersIncludingPairs(schedule, ordersToAssign) as Collection <Order>;
}
// Change orders planned date
foreach (Order order in ordersToAssign)
{
order.PlannedDate = targetDate;
}
App.Current.Project.Save();
// add info message to MessageWindow
string infoMessage = string.Format((string)App.Current.FindResource("DropOnDateCmdSuccessText"), ordersToAssign.Count, App.Current.CurrentDate.ToShortDateString(), targetDate.ToShortDateString());
App.Current.Messenger.AddInfo(infoMessage);
// clear unassigned orders for all schedule in current date
foreach (Schedule schedule in currentSchedules)
{
if (schedule.UnassignedOrders != null)
{
schedule.UnassignedOrders.Dispose();
schedule.UnassignedOrders = null;
}
}
// clear unassigned orders for all schedule in target date
ICollection <Schedule> targetSchedules = App.Current.Project.Schedules.Search(targetDate);
foreach (Schedule schedule in targetSchedules)
{
if (schedule.UnassignedOrders != null)
{
schedule.UnassignedOrders.Dispose();
schedule.UnassignedOrders = null;
}
}
OptimizeAndEditPage optimizeAndEditPage = (OptimizeAndEditPage)App.Current.MainWindow.GetPage(PagePaths.SchedulePagePath);
if (ordersToAssign[0].PlannedDate != optimizeAndEditPage.CurrentSchedule.PlannedDate)
{
optimizeAndEditPage.DeleteStoredSelection(optimizeAndEditPage.CurrentSchedule.PlannedDate.Value);
}
// schedule has changed - all views should be refreshed
optimizeAndEditPage.OnScheduleChanged(optimizeAndEditPage.CurrentSchedule);
// update days statuses
DayStatusesManager.Instance.UpdateDayStatus(App.Current.CurrentDate);
DayStatusesManager.Instance.UpdateDayStatus(targetDate);
// clear selection in OptimizeAndEditPage
optimizeAndEditPage.SelectedItems.Clear();
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="optimizeAndEditPage">Parent page.</param>
public SelectionChanger(OptimizeAndEditPage optimizeAndEditPage)
{
Debug.Assert(optimizeAndEditPage != null);
_optimizeAndEditPage = optimizeAndEditPage;
}
/// <summary> /// Checks whether command option is enabled. /// </summary> protected abstract void _CheckEnabled(OptimizeAndEditPage schedulePage);
/// <summary>
/// Excecutes command.
/// </summary>
/// <param name="args"></param>
protected override void _Execute(params object[] args)
{
try
{
OptimizeAndEditPage schedulePage = (OptimizeAndEditPage)App.Current.MainWindow.GetPage(PagePaths.SchedulePagePath);
Schedule schedule = schedulePage.CurrentSchedule;
// Get selected orders.
Collection <Order> selectedOrders = _GetOrdersWhichCanBeMovedFromSelection(schedulePage.SelectedItems);
selectedOrders = RoutingCmdHelpers.GetOrdersIncludingPairs(schedule, selectedOrders) as Collection <Order>;
bool keepViolOrdrsUnassigned = false;
Debug.Assert(args[0] != null);
ICollection <Route> targetRoutes = args[0] as ICollection <Route>;
Debug.Assert(targetRoutes != null);
string routeName = args[1] as string;
if (_CheckRoutingParams(schedule, targetRoutes, selectedOrders))
{
SolveOptions options = new SolveOptions();
options.GenerateDirections = App.Current.MapDisplay.TrueRoute;
options.FailOnInvalidOrderGeoLocation = false;
_SetOperationStartedStatus((string)App.Current.FindResource(ASSIGN_ORDERS), (DateTime)schedule.PlannedDate);
// Start "Assign to best other route" operation.
OperationsIds.Add(App.Current.Solver.AssignOrdersAsync(schedule, selectedOrders,
targetRoutes, null,
keepViolOrdrsUnassigned,
options));
// Set solve started message
string infoMessage = RoutingMessagesHelper.GetAssignOperationStartedMessage(selectedOrders, routeName);
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;
}
}
}
