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>
/// Creates request.
/// </summary>
/// <returns>Created VRP request.</returns>
public SubmitVrpJobRequest CreateRequest()
{
// check number of allowed routes
_CheckLicensePermissions();
// get orders and routes to solve
SolveRequestData reqData = this.RequestData;
// validate request data
_ValidateReqData(reqData);
// build request
SubmitVrpJobRequest req = BuildRequest(reqData);
// set operation info for logging
req.OperationType = this.OperationType;
req.OperationDate = (DateTime)_schedule.PlannedDate;
if (req.PointBarriers != null)
{
_pointBarriers = req.PointBarriers.Features;
}
if (req.LineBarriers != null)
{
_polylineBarriers = req.LineBarriers.Features;
}
if (req.PolygonBarriers != null)
{
_polygonBarriers = req.PolygonBarriers.Features;
}
return(req);
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
private SolveRequestData _BuildRequestData()
{
// exclude ungeocoded orders
List <Order> orders = new List <Order>();
foreach (Order order in _inputParams.OrdersToAssign)
{
if (order.IsGeocoded)
{
orders.Add(order);
}
else
{
var violation = new Violation()
{
ViolationType = ViolationType.Ungeocoded,
AssociatedObject = order
};
_violations.Add(violation);
}
}
// get barriers planned on schedule's date
DateTime day = (DateTime)Schedule.PlannedDate;
ICollection <Barrier> barriers = SolverContext.Project.Barriers.Search(day);
SolveRequestData reqData = new SolveRequestData();
reqData.Routes = _inputParams.TargetRoutes;
reqData.Orders = orders;
reqData.Barriers = barriers;
return(reqData);
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Builds request.
/// </summary>
/// <param name="reqData">Solve request data.</param>
/// <returns>Submit VRP job request.</returns>
protected virtual SubmitVrpJobRequest BuildRequest(SolveRequestData reqData)
{
return(this.RequestBuilder.BuildRequest(
_schedule,
reqData,
this.RequestOptions,
this.Options));
}
protected override VrpOperation CreateOperation(SolveRequestData reqData,
List <Violation> violations)
{
return(new SequenceRoutesOperation(base.SolverContext, base.Schedule,
_inputParams,
base.Options,
reqData,
violations));
}
protected override VrpOperation CreateOperation(SolveRequestData reqData,
List <Violation> violations)
{
return(new AssignOrdersOperation(base.SolverContext, base.Schedule, _inputParams,
base.Options,
reqData,
_reqBuilder,
violations));
}
public override SolveResult CreateResultWithoutSolve()
{
SolveRequestData reqData = this.RequestData;
foreach (Route route in reqData.Routes)
{
SolverContext.Project.Schedules.ClearRouteResults(route);
}
return(new SolveResult(null, null, false));
}
protected override SubmitVrpJobRequest BuildRequest(
SolveRequestData reqData)
{
SubmitVrpJobRequest req = base.BuildRequest(reqData);
_AdjustRequestWithTargetSequence(req, _inputParams, _violations);
_jobRequest = req;
return(req);
}
/// <summary>
/// Creates orders assigning operation result without solving.
/// </summary>
/// <param name="context">Solve operation context.</param>
/// <param name="requestData">Solve operation request data.</param>
/// <param name="violations">Violations found upon request building.</param>
/// <returns>Result of the solve for the specified request.</returns>
public static SolveResult CreateResultWithoutSolve(
SolverContext context,
SolveRequestData requestData,
IEnumerable <Violation> violations)
{
foreach (var route in requestData.Routes)
{
context.Project.Schedules.ClearRouteResults(route);
}
return(new SolveResult(null, violations.ToArray(), false));
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
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;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
private SolveRequestData _BuildRequestData()
{
List <Route> routes = new List <Route>();
List <Order> orders = new List <Order>();
// get unlocked routes from RoutesToSequence and all orders
// assigned to converting routes
foreach (Route route in _inputParams.RoutesToSequence)
{
if (route.Schedule.Equals(Schedule))
{
if (!route.IsLocked)
{
routes.Add(route);
orders.AddRange(SolveHelper.GetAssignedOrders(route));
}
}
else
{
// route does not have corresponding route results that
// belongs to schedule
throw new RouteException(String.Format(
Properties.Messages.Error_InvalidRouteToSequence,
route.Id));
}
}
// check if we have unlocked routes
if (routes.Count == 0)
{
throw new RouteException(Properties.Messages.Error_InvalidRoutesToSequenceCount);
}
// get barriers planned on schedule's date
ICollection <Barrier> barriers = SolverContext.Project.Barriers.Search(
(DateTime)Schedule.PlannedDate);
SolveRequestData reqData = new SolveRequestData();
reqData.Routes = routes;
reqData.Orders = orders;
reqData.Barriers = barriers;
return(reqData);
}
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;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
private SolveRequestData _BuildRequestData()
{
// get unlocked assigned orders for schedule
List <Order> unlockedAssignedOrders = _GetUnlockedAssignedOrders();
// select unlocked assigned orders from OrdersToUnassign
List <Order> unlockedOrdersToUnassign = new List <Order>();
foreach (Order order in _inputParams.OrdersToUnassign)
{
if (unlockedAssignedOrders.Contains(order))
{
unlockedOrdersToUnassign.Add(order);
}
}
// get affected routes:
// routes planned on schedule's day where each route has at
// least one order from UnlockedOrdersToUnassign assigned to it
List <Route> affectedRoutes = _GetAffectedRoutes(
Schedule.Routes,
unlockedOrdersToUnassign);
// get orders to convert:
// orders assigned to affected routes except those from
// UnlockedOrdersToUnassign
List <Order> ordersToConvert = _GetOrdersToConvert(
affectedRoutes,
unlockedOrdersToUnassign);
// get barriers planned on schedule's date
ICollection <Barrier> barriers = SolverContext.Project.Barriers.Search(
(DateTime)Schedule.PlannedDate);
SolveRequestData reqData = new SolveRequestData();
reqData.Routes = affectedRoutes;
reqData.Orders = ordersToConvert;
reqData.Barriers = barriers;
return(reqData);
}
private void _ValidateReqData(SolveRequestData reqData)
{
Debug.Assert(reqData != null);
// check routes count
if (reqData.Routes.Count < 1)
{
throw new RouteException(Properties.Messages.Error_InvalidRoutesNum);
}
// validate objects
var invalidObjects = new List <DataObject>();
invalidObjects.AddRange(_ValidateObjects <Order>(reqData.Orders));
invalidObjects.AddRange(_ValidateObjects <Route>(reqData.Routes));
if (invalidObjects.Count > 0)
{
throw new RouteException(Properties.Messages.Error_InvalidScheduleData,
invalidObjects.ToArray());
}
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Creates operation.
/// </summary>
/// <param name="reqData">Solve request data.</param>
/// <param name="violations">List of violations.</param>
/// <returns>Created VRP opeartion.</returns>
protected abstract VrpOperation CreateOperation(SolveRequestData reqData,
List <Violation> violations);
protected override VrpOperation CreateOperation(SolveRequestData reqData,
List <Violation> violations)
{
throw new NotSupportedException();
}
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);
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
private SolveRequestData _BuildRequestData()
{
// validate target sequence conditions
if (_inputParams.TargetSequence != null)
{
if (_inputParams.TargetSequence < 1)
{
throw new RouteException(Properties.Messages.Error_InvalidTargetSequence);
}
if (_inputParams.OrdersToAssign.Count != 1)
{
throw new RouteException(Properties.Messages.Error_InvalidOrdersToAssignCount);
}
if (_inputParams.TargetRoutes.Count != 1)
{
throw new RouteException(Properties.Messages.Error_InvalidTargetRoutesCount);
}
}
// get unlocked target routes
List <Route> unlockedTargetRoutes = new List <Route>();
foreach (Route route in _inputParams.TargetRoutes)
{
// TODO: (?) check if route belongs to processing schedule
if (!route.IsLocked)
{
unlockedTargetRoutes.Add(route);
}
}
// check if we have at least one unlocked route
if (unlockedTargetRoutes.Count == 0)
{
throw new RouteException(Properties.Messages.Error_InvalidUnlockedTargetRoutesCount);
}
// get unlocked orders
List <Order> unlockedOrdersToAssign = new List <Order>();
foreach (Order order in _inputParams.OrdersToAssign)
{
if (!SolveHelper.IsOrderLocked(order, Schedule))
{
unlockedOrdersToAssign.Add(order);
}
}
// check if we have at least one unlocked order
if (unlockedOrdersToAssign.Count == 0)
{
throw new RouteException(Properties.Messages.Error_InvalidUnlockedOrdersToAssignCount);
}
// get source routes:
// routes planned on schedule's day where each route has at
// least one order from UnlockedOrdersToAssign assigned to it
List <Route> sourceRoutes = _GetSourceRoutes(Schedule.Routes,
unlockedOrdersToAssign);
// routes to convert: TargetRoutes and SourceRoutes
List <Route> routes = new List <Route>();
routes.AddRange(_inputParams.TargetRoutes);
routes.AddRange(sourceRoutes);
// orders to convert:
// orders assigned to converting routes and unassigned orders
// from UnlockedOrdersToAssign
List <Order> candidateOrders = _GetAssignedOrders(routes);
candidateOrders.AddRange(unlockedOrdersToAssign);
var orders = new List <Order>();
foreach (var order in candidateOrders)
{
if (order.IsGeocoded)
{
orders.Add(order);
}
else
{
var violation = new Violation()
{
ViolationType = ViolationType.Ungeocoded,
AssociatedObject = order
};
_violations.Add(violation);
}
}
// check if SourceRoutes contains routes that are not contained in
// UnlockedTargetRoutes
if (_inputParams.TargetSequence == null)
{
foreach (Route srcRoute in sourceRoutes)
{
if (!unlockedTargetRoutes.Contains(srcRoute))
{
_hasSrcRoutesNotInTargetRoutes = true;
break;
}
}
}
// get barriers planned on schedule's date
ICollection <Barrier> barriers = SolverContext.Project.Barriers.Search(
(DateTime)Schedule.PlannedDate);
_sourceRoutes = sourceRoutes;
_unlockedOrdersToAssign = unlockedOrdersToAssign;
_unlockedTargetRoutes = unlockedTargetRoutes;
_barriers = barriers;
SolveRequestData reqData = new SolveRequestData();
reqData.Routes = new List <Route>(routes.Distinct());
reqData.Orders = new List <Order>(orders.Distinct());
reqData.Barriers = barriers;
return(reqData);
}
