///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
public AssignOrdersOperation(SolverContext context,
Schedule schedule,
AssignOrdersParams inputParams,
SolveOptions options)
: base(context, schedule, options)
{
Debug.Assert(inputParams != null);
_inputParams = inputParams;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
public SequenceRoutesOperation(SolverContext context,
Schedule schedule,
SequenceRoutesParams inputParams,
SolveOptions options)
: base(context, schedule, options)
{
Debug.Assert(inputParams != null);
_inputParams = inputParams;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
public SequenceRoutesOperation(SolverContext context,
Schedule schedule,
SequenceRoutesParams inputParams,
SolveOptions options)
: base(context, schedule, options)
{
Debug.Assert(inputParams != null);
_inputParams = inputParams;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
public BuildRoutesOperation(SolverContext context,
Schedule schedule,
SolveOptions options,
BuildRoutesParameters inputParams)
: base(context, schedule, options)
{
Debug.Assert(inputParams != null);
_inputParams = inputParams;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
public BuildRoutesOperation(SolverContext context,
Schedule schedule,
SolveOptions options,
BuildRoutesParameters inputParams)
: base(context, schedule, options)
{
Debug.Assert(inputParams != null);
_inputParams = inputParams;
}
/// <summary>
/// Asynchronously builds routes for specified schedule.
/// </summary>
/// <param name="schedule">Schedule object.</param>
/// <param name="options">Solve options.</param>
/// <param name="inputParams">Input parameters for build route operation.</param>
/// <returns>
/// Operation id.
/// </returns>
public Guid BuildRoutesAsync(Schedule schedule,
SolveOptions options,
BuildRoutesParameters inputParams)
{
BuildRoutesOperation operation = new BuildRoutesOperation(_context,
schedule,
options,
inputParams);
return(_RunAsync(operation));
}
public Guid UnassignOrdersAsync(Schedule schedule,
ICollection <Order> ordersToUnassign,
SolveOptions options)
{
UnassignOrdersOperation operation = new UnassignOrdersOperation(
_context,
schedule,
new UnassignOrdersParams(ordersToUnassign),
options);
return(_RunAsync(operation));
}
public Guid SequenceRoutesAsync(Schedule schedule,
ICollection <Route> routesToSequence,
SolveOptions options)
{
SequenceRoutesOperation operation = new SequenceRoutesOperation(
_context,
schedule,
new SequenceRoutesParams(routesToSequence),
options);
return(_RunAsync(operation));
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
public AssignOrdersStep2(SolverContext context,
Schedule schedule,
SolveRequestData reqData,
AssignOrdersParams inputParams,
IList<RouteResult> prevRouteResults,
IList<Violation> prevViolations,
SolveOptions options)
: base(context, schedule, options)
{
_reqData = reqData;
_inputParams = inputParams;
_prevRouteResults = prevRouteResults;
_prevViolations = prevViolations;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
public AssignOrdersStep2(SolverContext context,
Schedule schedule,
SolveRequestData reqData,
AssignOrdersParams inputParams,
IList <RouteResult> prevRouteResults,
IList <Violation> prevViolations,
SolveOptions options)
: base(context, schedule, options)
{
_reqData = reqData;
_inputParams = inputParams;
_prevRouteResults = prevRouteResults;
_prevViolations = prevViolations;
}
public BuildRoutesOperation(SolverContext context,
Schedule schedule,
SolveOptions options,
SolveRequestData reqData,
List<Violation> violations,
BuildRoutesParameters inputParams)
: base(context, schedule, options)
{
Debug.Assert(reqData != null);
Debug.Assert(violations != null);
Debug.Assert(inputParams != null);
_reqData = reqData;
_violations = violations;
_inputParams = inputParams;
}
public BuildRoutesOperation(SolverContext context,
Schedule schedule,
SolveOptions options,
SolveRequestData reqData,
List <Violation> violations,
BuildRoutesParameters inputParams)
: base(context, schedule, options)
{
Debug.Assert(reqData != null);
Debug.Assert(violations != null);
Debug.Assert(inputParams != null);
_reqData = reqData;
_violations = violations;
_inputParams = inputParams;
}
public AssignOrdersOperation(SolverContext context,
Schedule schedule,
AssignOrdersParams inputParams,
SolveOptions options,
SolveRequestData reqData,
AssignOrdersReqBuilder reqBuilder,
List <Violation> violations)
: base(context, schedule, options)
{
Debug.Assert(inputParams != null);
Debug.Assert(reqData != null);
Debug.Assert(reqBuilder != null);
Debug.Assert(violations != null);
_inputParams = inputParams;
_reqData = reqData;
_reqBuilder = reqBuilder;
_violations = violations;
}
public Guid AssignOrdersAsync(Schedule schedule,
ICollection <Order> ordersToAssign,
ICollection <Route> targetRoutes,
int?targetSequence,
bool keepViolatedOrdersUnassigned,
SolveOptions options)
{
AssignOrdersParams inputParams = new AssignOrdersParams(
ordersToAssign,
targetRoutes,
targetSequence,
keepViolatedOrdersUnassigned);
AssignOrdersOperation operation = new AssignOrdersOperation(
_context,
schedule,
inputParams,
options);
return(_RunAsync(operation));
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Method collect information from solve request data for planned date and build request
/// object.
/// </summary>
/// <param name="schedule">Current schedule.</param>
/// <param name="reqData">Request data to get information.</param>
/// <param name="options">Request options.</param>
/// <param name="solveOptions">The reference to to the solve options object.</param>
/// <returns>Request object with filled information for request.</returns>
/// <exception cref="RouteException">If Fuel Economy in some of routes is 0.0,
/// If unassigned order or location is not geocoded.</exception>
public SubmitVrpJobRequest BuildRequest(Schedule schedule, SolveRequestData reqData,
SolveRequestOptions options, SolveOptions solveOptions)
{
Debug.Assert(schedule != null);
Debug.Assert(reqData != null);
Debug.Assert(options != null);
Debug.Assert(solveOptions != null);
_plannedDate = (DateTime)schedule.PlannedDate;
_orderRevenue = Math.Min(_CalcMaxRoutesCost(reqData.Routes),
MAX_REVENUE);
_BuildDepotsColl(reqData.Routes);
SubmitVrpJobRequest req = new SubmitVrpJobRequest();
// Get depots.
req.Depots = _ConvertDepots();
// Get orders.
req.Orders = _ConvertOrders(reqData.Orders, reqData.Routes,
options.ConvertUnassignedOrders);
// Get order pairs.
req.OrderPairs = _ConvertOrderPairs(reqData.Orders);
// Get routes.
req.Routes = _ConvertRoutes(reqData.Routes);
// Get route zones.
var zoneInfo = _ConvertZones(reqData.Routes);
req.RouteZones = zoneInfo.Zones;
req.SpatiallyClusterRoutes = zoneInfo.UseSpatialClustering;
// Get renewals.
req.Renewals = _ConvertRenewals(reqData.Routes);
// Get breaks.
req.Breaks = ConvertBreaks(reqData.Routes);
// Get barriers of all types.
var typedBarriers = reqData.Barriers.ToLookup(BarriersConverter.DetermineBarrierType);
req.PointBarriers = _ConvertBarriers(typedBarriers, BarrierGeometryType.Point,
_context.NetworkDescription.NetworkAttributes);
req.PolygonBarriers = _ConvertBarriers(typedBarriers, BarrierGeometryType.Polygon,
_context.NetworkDescription.NetworkAttributes);
req.LineBarriers = _ConvertBarriers(typedBarriers, BarrierGeometryType.Polyline,
_context.NetworkDescription.NetworkAttributes);
// Get network attribute parameters.
req.NetworkParams = _ConvertNetworkParams();
// Get analysis region.
req.AnalysisRegion = _context.RegionName;
// Get restrictions.
req.Restrictions = _FormatRestrictions();
// Get u-turn policy.
req.UTurnPolicy = _GetUTurnPolicy();
req.Date = GPObjectHelper.DateTimeToGPDateTime(_plannedDate);
req.UseHierarchyInAnalysis = true;
req.PopulateRouteLines = false;
req.EnvOutSR = solverSR.WKID;
req.EnvProcessSR = solverSR.WKID;
req.TWPreference = _context.SolverSettings.TWPreference;
req.ExcludeRestrictedStreets = _context.SolverSettings.ExcludeRestrictedStreets;
req.OutputFormat = NAOutputFormat.JSON;
req.DirectionsLanguage = RequestBuildingHelper.GetDirectionsLanguage();
req.PopulateDirections = options.PopulateRouteLines;
req.SaveOutputLayer = _context.SolverSettings.SaveOutputLayer;
req.ReturnM = true;
return req;
}
/// <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;
}
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Create a new instance of the <c>VrpOperation</c> class.
/// </summary>
/// <param name="context">Solver context.</param>
/// <param name="schedule">Current schedule.</param>
/// <param name="options">Solve options.</param>
public VrpOperation(SolverContext context, Schedule schedule, SolveOptions options)
{
_context = context;
_schedule = schedule;
_options = options;
}
/// <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>
/// 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>
/// 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);
}
}