///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
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);
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
internal SolveResult(ServerMessage[] messages, Violation[] violations,
bool isFailed)
{
if (messages != null)
_messages.AddRange(messages);
if (violations != null)
_violations.AddRange(violations);
_isFailed = isFailed;
}
/// <summary>
/// Method creates a collection of violations for collection of Violation Constraint entries.
/// </summary>
/// <param name="violatedConstraint">Violated constraint.</param>
/// <param name="hresult">HResult.</param>
/// <param name="assocObject">Associated object.</param>
/// <param name="entries">Collection of Violation Constraint entries.</param>
/// <returns>Collection of Violations.</returns>
private static List<Violation> _CreateViolations(int violatedConstraint,
int hresult,
DataObject assocObject,
VCEntry[] entries)
{
var list = new List<Violation>();
foreach (VCEntry entry in entries)
{
int naType = (int)entry.NAType;
if ((violatedConstraint & naType) == naType)
{
Violation violation = new Violation();
violation.ViolationType = entry.type;
violation.AssociatedObject = assocObject;
// Get extended info for HRESULT.
foreach (VCDesc hrDesc in entry.hrDesc)
{
if (hresult == hrDesc.HR)
{
// Override violation type.
violation.ViolationType = hrDesc.subType;
break;
}
}
list.Add(violation);
}
}
return list;
}
/// <summary>
/// Method creates violation for restricted object according to its status.
/// </summary>
/// <param name="status">Object status.</param>
/// <param name="assocObject">Associated object.</param>
/// <returns>Violation.</returns>
private static Violation _CreateRestrictedObjViolation(NAObjectStatus status,
DataObject assocObject)
{
var violation = new Violation();
violation.AssociatedObject = assocObject;
if (status == NAObjectStatus.esriNAObjectStatusNotLocated ||
status == NAObjectStatus.esriNAObjectStatusElementNotLocated)
{
violation.ViolationType = ViolationType.TooFarFromRoad;
}
else if (status == NAObjectStatus.esriNAObjectStatusElementNotTraversable)
{
violation.ViolationType = ViolationType.RestrictedStreet;
}
else
Debug.Assert(false);
return violation;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
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;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
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);
}
protected override List <Violation> GetViolations(VrpResult vrpResult)
{
List <Violation> violations = base.GetViolations(vrpResult);
Order violatedOrder = null;
Violation specViolation = null;
foreach (Violation v in violations)
{
if (v.ViolationType == ViolationType.Specialties &&
v.ObjectType == ViolatedObjectType.Order)
{
violatedOrder = v.AssociatedObject as Order;
specViolation = v;
break;
}
}
if (violatedOrder != null)
{
List <Guid> specIds = new List <Guid>();
foreach (DriverSpecialty spec in violatedOrder.DriverSpecialties)
{
if (spec.Id != AssignOrdersReqBuilder.ASSIGNMENT_SPEC_ID)
{
specIds.Add(spec.Id);
}
}
foreach (VehicleSpecialty spec in violatedOrder.VehicleSpecialties)
{
if (spec.Id != AssignOrdersReqBuilder.ASSIGNMENT_SPEC_ID)
{
specIds.Add(spec.Id);
}
}
bool removeSpecViolation = true;
if (specIds.Count > 0)
{
foreach (Guid specId in specIds)
{
foreach (GPFeature feature in _jobRequest.Routes.Features)
{
if (!_IsSpecBelongToRoute(specId, feature))
{
removeSpecViolation = false;
break;
}
}
if (!removeSpecViolation)
{
break;
}
}
}
if (removeSpecViolation)
{
violations.Remove(specViolation);
}
}
if (_violations != null)
{
violations.AddRange(_violations);
}
return(violations);
}
