///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
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 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>
/// 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>
/// Method gets number of orders, which was reassigned in result of operation.
/// </summary>
/// <param name="parameters">Operation parameters.</param>
/// <returns>Number of reassigned orders.</returns>
private static int _GetNumberOfReassignedOrders(AssignOrdersParams parameters)
{
Debug.Assert(parameters != null);
ICollection <Order> ordersToAssign = parameters.OrdersToAssign;
ICollection <Route> targetRoutes = parameters.TargetRoutes;
var targetOrderSequence = parameters.TargetOrderSequence;
int numberOfReassignedOrders = 0;
foreach (Order order in ordersToAssign)
{
if (_IsOrderAssignedToRoute(order, targetRoutes, targetOrderSequence))
{
numberOfReassignedOrders++;
}
}
return(numberOfReassignedOrders);
}
/// <summary>
/// Method shows result messages for operation with Parial Success.
/// </summary>
/// <param name="violations">List of operations occured.</param>
/// <param name="schedule">Schedule.</param>
/// <param name="info">Operation info.</param>
private void _ShowPartialSuccessOperationResults(IList <Violation> violations,
Schedule schedule, AsyncOperationInfo info)
{
// Add violations results.
ICollection <MessageDetail> details =
ViolationMessageBuilder.GetViolationDetails(schedule,
info, violations);
// For Build Routes or Assign to Best Route operations
// after violations list add successfully moved orders results.
if (info.OperationType == SolveOperationType.BuildRoutes)
{
var routedOrdersDetails =
_GetSuccessfullyAssignedOrdersDetails(schedule, info);
foreach (var detail in routedOrdersDetails)
{
details.Add(detail);
}
}
else if (info.OperationType == SolveOperationType.AssignOrders)
{
AssignOrdersParams parameters = (AssignOrdersParams)info.InputParams;
// Is this operation is targeted to Best Route.
if (parameters.TargetRoutes.Count > 1)
{
var assignedOrdersDetails =
_GetSuccessfullyAssignedOrdersDetails(schedule, info);
foreach (var detail in assignedOrdersDetails)
{
details.Add(detail);
}
}
}
App.Current.Messenger.AddMessage(
_FormatSuccessSolveCompletedMsg(schedule, info), details);
}
/// <summary>
/// Method gets orders sent for routing operation, if appropriate operation
/// support orders for assigning.
/// </summary>
/// <param name="info">Operation information.</param>
/// <returns>Collection of orders to assign or null if operation
/// doesn't support orders to assign.</returns>
private ICollection <Order> _GetOrdersToAssign(AsyncOperationInfo info)
{
Debug.Assert(info != null);
ICollection <Order> orders = null;
if (info.OperationType == SolveOperationType.BuildRoutes)
{
BuildRoutesParameters parameters = (BuildRoutesParameters)info.InputParams;
orders = parameters.OrdersToAssign;
}
else if (info.OperationType == SolveOperationType.AssignOrders)
{
AssignOrdersParams parameters = (AssignOrdersParams)info.InputParams;
orders = parameters.OrdersToAssign;
}
else
{
// Do nothing: other operation doesn't support OrdersToAssign.
}
return(orders);
}
/// <summary>
/// Method gets number of orders, which was reassigned in result of operation.
/// </summary>
/// <param name="parameters">Operation parameters.</param>
/// <returns>Number of reassigned orders.</returns>
private static int _GetNumberOfReassignedOrders(AssignOrdersParams parameters)
{
Debug.Assert(parameters != null);
ICollection<Order> ordersToAssign = parameters.OrdersToAssign;
ICollection<Route> targetRoutes = parameters.TargetRoutes;
var targetOrderSequence = parameters.TargetOrderSequence;
int numberOfReassignedOrders = 0;
foreach (Order order in ordersToAssign)
{
if (_IsOrderAssignedToRoute(order, targetRoutes, targetOrderSequence))
{
numberOfReassignedOrders++;
}
}
return numberOfReassignedOrders;
}
