///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
protected override void SetOrderAssignment(AttrDictionary attrs,
AssignedOrder assignedOrder)
{
if (assignedOrder.Route.IsLocked)
{
// order is assigned to a locked route
attrs.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderExcludeFromSolve);
}
else if (assignedOrder.Stop.IsLocked)
{
// order is locked itself
attrs.Set(NAAttribute.ROUTE_NAME, assignedOrder.Route.Id.ToString());
attrs.Set(NAAttribute.SEQUENCE, assignedOrder.SequenceNumber);
attrs.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderPreserveRouteAndRelativeSequence);
}
else
{
attrs.Set(NAAttribute.ROUTE_NAME, "");
attrs.Set(NAAttribute.SEQUENCE, null);
attrs.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderOverride);
}
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
protected override void SetOrderAssignment(AttrDictionary attrs,
AssignedOrder assignedOrder)
{
if (assignedOrder.Route.IsLocked)
{
// order is assigned to a locked route
attrs.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderExcludeFromSolve);
}
else if (assignedOrder.Stop.IsLocked)
{
// order is locked itself
attrs.Set(NAAttribute.ROUTE_NAME, assignedOrder.Route.Id.ToString());
attrs.Set(NAAttribute.SEQUENCE, assignedOrder.SequenceNumber);
attrs.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderPreserveRouteAndRelativeSequence);
}
else
{
attrs.Set(NAAttribute.ROUTE_NAME, "");
attrs.Set(NAAttribute.SEQUENCE, null);
attrs.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderOverride);
}
}
public async Task <Response> Handle(Request request, CancellationToken cancellationToken)
{
var assignedOrder = await _context.AssignedOrders.FindAsync(request.AssignedOrder.AssignedOrderId);
if (assignedOrder == null)
{
assignedOrder = new AssignedOrder();
_context.AssignedOrders.Add(assignedOrder);
}
await _context.SaveChangesAsync(cancellationToken);
return(new Response()
{
});
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
protected override void SetOrderAssignment(AttrDictionary attrs,
AssignedOrder assignedOrder)
{
if (!_unlockedOrdersToAssign.Contains(assignedOrder.Order))
{
attrs.Set(NAAttribute.ROUTE_NAME, assignedOrder.Route.Id.ToString());
attrs.Set(NAAttribute.SEQUENCE, assignedOrder.SequenceNumber);
attrs.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderPreserveRouteAndRelativeSequence);
}
else
{
attrs.Set(NAAttribute.ROUTE_NAME, "");
attrs.Set(NAAttribute.SEQUENCE, null);
attrs.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderOverride);
}
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
protected override void SetOrderAssignment(AttrDictionary attrs,
AssignedOrder assignedOrder)
{
if (assignedOrder.Route.IsLocked ||
assignedOrder.Stop.IsLocked)
{
attrs.Set(NAAttribute.ROUTE_NAME, assignedOrder.Route.Id.ToString());
attrs.Set(NAAttribute.SEQUENCE, assignedOrder.SequenceNumber);
attrs.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderPreserveRouteAndRelativeSequence);
}
else
{
attrs.Set(NAAttribute.ROUTE_NAME, assignedOrder.Route.Id.ToString());
attrs.Set(NAAttribute.SEQUENCE, assignedOrder.SequenceNumber);
attrs.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderPreserveRoute);
}
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
protected override void SetOrderAssignment(AttrDictionary attrs,
AssignedOrder assignedOrder)
{
if (assignedOrder.Route.IsLocked ||
assignedOrder.Stop.IsLocked)
{
attrs.Set(NAAttribute.ROUTE_NAME, assignedOrder.Route.Id.ToString());
attrs.Set(NAAttribute.SEQUENCE, assignedOrder.SequenceNumber);
attrs.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderPreserveRouteAndRelativeSequence);
}
else
{
attrs.Set(NAAttribute.ROUTE_NAME, assignedOrder.Route.Id.ToString());
attrs.Set(NAAttribute.SEQUENCE, assignedOrder.SequenceNumber);
attrs.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderPreserveRoute);
}
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
protected override void SetOrderAssignment(AttrDictionary attrs,
AssignedOrder assignedOrder)
{
if (!_unlockedOrdersToAssign.Contains(assignedOrder.Order))
{
attrs.Set(NAAttribute.ROUTE_NAME, assignedOrder.Route.Id.ToString());
attrs.Set(NAAttribute.SEQUENCE, assignedOrder.SequenceNumber);
attrs.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderPreserveRouteAndRelativeSequence);
}
else
{
attrs.Set(NAAttribute.ROUTE_NAME, "");
attrs.Set(NAAttribute.SEQUENCE, null);
attrs.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderOverride);
}
}
public static AssignedOrderDto ToDto(this AssignedOrder assignedOrder)
=> new AssignedOrderDto
{
};
/// <summary>
/// Method converts order into GPFeature.
/// </summary>
/// <param name="unassignedOrder">Unassigned order to convert.</param>
/// <param name="assignedOrder">Assigned order to convert.</param>
/// <returns>Orders GPFeature.</returns>
/// <exception cref="RouteException">If unassigned order is not geocoded.</exception>
private GPFeature _ConvertOrder(Order unassignedOrder, AssignedOrder assignedOrder)
{
Debug.Assert(unassignedOrder != null);
GPFeature feature = new GPFeature();
// Geometry.
IGeocodable gc = unassignedOrder as IGeocodable;
Debug.Assert(gc != null);
if (!gc.IsGeocoded)
{
throw new RouteException(String.Format(
Properties.Messages.Error_OrderIsUngeocoded, unassignedOrder.Id));
}
Debug.Assert(gc.GeoLocation != null);
feature.Geometry = new GeometryHolder();
feature.Geometry.Value = GPObjectHelper.PointToGPPoint((Point)gc.GeoLocation);
// Attributes.
AttrDictionary attrs = new AttrDictionary();
// Name.
attrs.Add(NAAttribute.NAME, unassignedOrder.Id.ToString());
// Curb approach.
attrs.Add(NAAttribute.CURB_APPROACH,
(int)CurbApproachConverter.ToNACurbApproach(
_context.SolverSettings.GetOrderCurbApproach()));
// Service time.
attrs.Add(NAAttribute.SERVICE_TIME, unassignedOrder.ServiceTime);
// Time windows.
TimeWindow timeWindow1 = unassignedOrder.TimeWindow;
TimeWindow timeWindow2 = unassignedOrder.TimeWindow2;
_SetTimeWindowsAttributes(attrs, ref timeWindow1, ref timeWindow2);
// Max Violation Time 1.
attrs.Add(NAAttribute.MAX_VIOLATION_TIME1,
timeWindow1.IsWideOpen ? (double?)null : unassignedOrder.MaxViolationTime);
// Max Violation Time 2.
attrs.Add(NAAttribute.MAX_VIOLATION_TIME2,
timeWindow2.IsWideOpen ? (double?)null : unassignedOrder.MaxViolationTime);
// PickUp or DropOff quantities.
string capacities = _FormatCapacities(unassignedOrder.Capacities);
if (unassignedOrder.Type == OrderType.Delivery)
{
attrs.Add(NAAttribute.DELIVERY, capacities);
attrs.Add(NAAttribute.PICKUP, null);
}
else
{
attrs.Add(NAAttribute.PICKUP, capacities);
attrs.Add(NAAttribute.DELIVERY, null);
}
// Revenue.
attrs.Add(NAAttribute.REVENUE,
unassignedOrder.Priority == OrderPriority.Normal ? 0 : (long)_orderRevenue);
// Specialties.
List<Guid> specIds = GetOrderSpecIds(unassignedOrder);
if (specIds.Count > 0)
attrs.Add(NAAttribute.SPECIALTY_NAMES, _FormatSpecList(specIds));
if (assignedOrder != null)
SetOrderAssignment(attrs, assignedOrder);
else
SetOrderAssignment(attrs, unassignedOrder);
// Status.
attrs.Add(NAAttribute.STATUS, (int)NAObjectStatus.esriNAObjectStatusOK);
feature.Attributes = attrs;
return feature;
}
///////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
/// <summary>
/// Method set assigned order attributes.
/// </summary>
/// <param name="attrs">Attributes to set.</param>
/// <param name="assignedOrder">Assigned order to get attribute values.</param>
protected virtual void SetOrderAssignment(AttrDictionary attrs, AssignedOrder assignedOrder)
{
Debug.Assert(attrs != null);
// Route name.
attrs.Set(NAAttribute.ROUTE_NAME, assignedOrder.Route.Id.ToString());
// Sequence.
attrs.Set(NAAttribute.SEQUENCE, assignedOrder.SequenceNumber);
// Assignment rule.
attrs.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderPreserveRouteAndRelativeSequence);
}
/// <summary>
/// Method gets collection of assigned orders from routes collection.
/// </summary>
/// <param name="routes">Routes collection to get information from.</param>
/// <returns>Collection of assigned orders.</returns>
private List<AssignedOrder> _GetAssignedOrders(ICollection<Route> routes)
{
Debug.Assert(routes != null);
List<AssignedOrder> orders = new List<AssignedOrder>();
foreach (Route route in routes)
{
foreach (Stop stop in route.Stops)
{
if (stop.StopType == StopType.Order)
{
AssignedOrder order = new AssignedOrder();
order.Order = stop.AssociatedObject as Order;
order.Route = route;
order.Stop = stop;
order.SequenceNumber = stop.SequenceNumber;
orders.Add(order);
}
}
}
return orders;
}
/// <summary>
/// Method determine if assigned order exists and returns it in output parameter.
/// </summary>
/// <param name="order">Order to find.</param>
/// <param name="assignedOrders">Collection of assigned orders to search in.</param>
/// <param name="assignedOrder">Output assigned order.</param>
/// <returns>True - if assigned order found, otherwise - false.</returns>
private bool _FindAssignedOrder(Order order, ICollection<AssignedOrder> assignedOrders,
out AssignedOrder assignedOrder)
{
assignedOrder = null;
bool found = false;
foreach (AssignedOrder ao in assignedOrders)
{
if (ao.Order.Equals(order))
{
assignedOrder = ao;
found = true;
break;
}
}
return found;
}
