private VrpOperation _GetRestrictedOrdersOperation(
List <Order> restrictedOrders,
List <Violation> violations)
{
Debug.Assert(restrictedOrders != null);
SolveRequestData reqData = this.RequestData;
var newOrders = new List <Order>();
foreach (Order order in reqData.Orders)
{
if (!restrictedOrders.Contains(order))
{
newOrders.Add(order);
}
}
VrpOperation operation = null;
if (newOrders.Count > 0)
{
reqData.Orders = newOrders;
operation = CreateOperation(reqData, violations);
}
return(operation);
}
/// <summary>
/// Processes result.
/// </summary>
/// <param name="vrpResult">VRP solve operation result.</param>
/// <param name="request">Request used for obtaining the response.</param>
/// <returns>Founded violations.</returns>
protected virtual List <Violation> ProcessResult(
VrpResult vrpResult,
SubmitVrpJobRequest request)
{
Debug.Assert(vrpResult != null);
Debug.Assert(request != null);
// get violations
List <Violation> violations = GetViolations(vrpResult);
VrpOperation nextStep = null;
if (CanConvertResult(vrpResult.SolveHR))
{
if (vrpResult.ResultObjects != null)
{
// convert VRP result
IList <RouteResult> routeResults = ConvertResult(vrpResult, request);
// check if we need next step
nextStep = GetNextStepOperation(routeResults, violations);
if (nextStep == null)
{
SetRouteResults(routeResults); // final step, set results to schedule
}
}
}
else if (!_options.FailOnInvalidOrderGeoLocation)
{
if (!_HasRestrictedDepots(violations))
{
List <Order> restrictedOrders = _GetRestrictedOrders(violations);
if (restrictedOrders.Count > 0)
{
nextStep = _GetRestrictedOrdersOperation(restrictedOrders, violations);
}
}
}
_nextStep = nextStep;
return(violations);
}
protected override VrpOperation GetNextStepOperation(
IList <RouteResult> routeResults,
List <Violation> violations)
{
bool isNextStepRequired = true;
// check if we need next step
if (!_hasSrcRoutesNotInTargetRoutes || // target routes include all source routes
violations.Count == 0 || // there are no violations
_inputParams.KeepViolatedOrdersUnassigned)
{
isNextStepRequired = false;
}
VrpOperation nextStep = null;
if (isNextStepRequired)
{
nextStep = _CreateNextStepOperation(routeResults, violations);
}
return(nextStep);
}
private VrpOperation _CreateNextStepOperation(
IList <RouteResult> routeResults,
IList <Violation> violations)
{
// get violated orders
List <Order> violatedOrders = new List <Order>();
foreach (Violation violation in violations)
{
if (violation.ObjectType == ViolatedObjectType.Order)
{
violatedOrders.Add(violation.AssociatedObject as Order);
}
}
// get routes to update:
// routes subset from SourceRouts collection where each route
// has at least one order from VilatedOrders assigned to it
List <Route> routesToUpdate = _GetRoutesToUpdate(_sourceRoutes,
violatedOrders);
VrpOperation nextStep = null;
if (routesToUpdate.Count > 0)
{
// get processed orders:
// orders that were successfully assigned to their new target routes
List <Order> processedOrders = new List <Order>();
foreach (Order order in _unlockedOrdersToAssign)
{
if (!violatedOrders.Contains(order))
{
processedOrders.Add(order);
}
}
// get orders assigned to RoutesToUpdate
List <Order> assignedOrders = _GetAssignedOrders(routesToUpdate);
// exclude processed orders
List <Order> ordersToUpdate = new List <Order>();
foreach (Order order in assignedOrders)
{
if (!processedOrders.Contains(order))
{
ordersToUpdate.Add(order);
}
}
if (ordersToUpdate.Count > 0)
{
SolveRequestData reqData = new SolveRequestData();
reqData.Routes = routesToUpdate;
reqData.Orders = ordersToUpdate;
reqData.Barriers = _barriers;
nextStep = new AssignOrdersStep2(SolverContext, Schedule, reqData,
_inputParams,
routeResults,
violations,
base.Options);
}
}
return(nextStep);
}
