/// <summary>
/// Submits job to the VRP service.
/// </summary>
/// <param name="request">Request describing job to be submitted.</param>
/// <returns>Result of the job submitting.</returns>
/// <exception cref="T:ESRI.ArcLogistics.Routing.RestException">error was
/// returned by the REST API.</exception>
/// <exception cref="T:ESRI.ArcLogistics.CommunicationException">failed
/// to communicate with the REST VRP service.</exception>
public GetVrpJobResultResponse SubmitJob(SubmitVrpJobRequest request)
{
Debug.Assert(request != null);
var url = UriHelper.Concat(_baseUrl, QUERY_OBJ_SUBMIT_JOB);
var query = RestHelper.BuildQueryString(
request,
_context.KnownTypes,
false);
// log request
Logger.Info(String.Format(MSG_SUBMIT_JOB, request.OperationType,
request.OperationDate.ToString("d"),
query));
HttpRequestOptions opt = new HttpRequestOptions();
opt.Method = HttpMethod.Post;
opt.UseGZipEncoding = true;
opt.Timeout = DEFAULT_REQ_TIMEOUT;
return(_restService.SendRequest <GetVrpJobResultResponse>(
_context,
url,
query,
opt));
}
protected override SubmitVrpJobRequest BuildRequest(
SolveRequestData reqData)
{
SubmitVrpJobRequest req = base.BuildRequest(reqData);
_AdjustRequestWithTargetSequence(req, _inputParams, _violations);
_jobRequest = req;
return(req);
}
/// <summary>
/// Adjusts VRP job request for cases when target sequence parameter is set.
/// Does nothing if <paramref name="parameters"/> have no target sequence
/// or order to be assigned is a violated one.
/// </summary>
/// <param name="request">Request to be adjusted.</param>
/// <param name="parameters">Assign orders operation parameters to be
/// used for adjusting the request.</param>
/// <param name="violations">Collection of violations to be checked.</param>
/// <exception cref="T:ESRI.ArcLogistics.Routing.RouteException">when
/// <paramref name="request"/> does not contain order from
/// <paramref name="parameters"/>.</exception>
private void _AdjustRequestWithTargetSequence(
SubmitVrpJobRequest request,
AssignOrdersParams parameters,
IEnumerable <Violation> violations)
{
Debug.Assert(request != null);
Debug.Assert(parameters != null);
Debug.Assert(violations != null);
if (!parameters.TargetSequence.HasValue)
{
return;
}
Debug.Assert(parameters.OrdersToAssign.Count == 1); // must contain a single order
Debug.Assert(parameters.TargetRoutes.Count == 1); // must contain a single route
var orderToAssign = parameters.OrdersToAssign.First();
Debug.Assert(orderToAssign != null);
if (violations.Any(v => v.AssociatedObject == orderToAssign))
{
return;
}
GPFeature targetFeature;
if (!_FindTargetFeature(request.Orders, orderToAssign, out targetFeature))
{
throw new RouteException(Properties.Messages.Error_InternalRouteError);
}
// free place for new order position
var targetSequence = parameters.TargetSequence.Value;
Debug.Assert(targetSequence > 0);
if (_HasSequence(request.Orders, targetSequence))
{
_ShiftSequence(request.Orders, targetSequence);
}
// set assignment attributes
var targetRoute = parameters.TargetRoutes.First();
Debug.Assert(targetRoute != null);
targetFeature.Attributes.Set(NAAttribute.SEQUENCE, targetSequence);
targetFeature.Attributes.Set(NAAttribute.ROUTE_NAME, targetRoute.Id.ToString());
targetFeature.Attributes.Set(NAAttribute.ASSIGNMENT_RULE,
(int)NAOrderAssignmentRule.esriNAOrderPreserveRouteAndRelativeSequence);
}
/// <summary>
/// Checks if the VRP request is short enough to be services with the
/// synchronous VRP service.
/// </summary>
/// <param name="request">The reference to the request object to be
/// analyzed.</param>
/// <returns>True if the request could be executed with a synchronous VRP
/// service.</returns>
public bool CanExecuteSyncronously(SubmitVrpJobRequest request)
{
Debug.Assert(request != null);
Debug.Assert(request.Orders != null);
Debug.Assert(request.Orders.Features != null);
Debug.Assert(request.Routes != null);
Debug.Assert(request.Routes.Features != null);
if (request.Orders.Features.Length > _maxOrders ||
request.Routes.Features.Length > _maxRoutes)
{
return(false);
}
return(true);
}
/// <summary>
/// Executes VRP job synchronously.
/// </summary>
/// <param name="request">The reference to the request object to be
/// send to the server.</param>
/// <returns>Result of the synchronous job execution.</returns>
/// <exception cref="T:ESRI.ArcLogistics.Routing.RestException">error was
/// returned by the REST API.</exception>
/// <exception cref="T:ESRI.ArcLogistics.CommunicationException">failed
/// to communicate with the REST VRP service.</exception>
public SyncVrpResponse ExecuteJob(SubmitVrpJobRequest request)
{
Debug.Assert(request != null);
Debug.Assert(_syncContext != null);
var url = UriHelper.Concat(_syncContext.Url, QUERY_OBJ_EXECUTE_TASK);
var query = RestHelper.BuildQueryString(
request,
_syncContext.Context.KnownTypes,
false);
var options = new HttpRequestOptions()
{
Method = HttpMethod.Post,
UseGZipEncoding = true,
Timeout = EXEC_TASK_TIMEOUT,
};
return(_syncRestService.SendRequest <SyncVrpResponse>(
_syncContext.Context,
url,
query,
options));
}
protected override IList <RouteResult> ConvertResult(
VrpResult vrpResult,
SubmitVrpJobRequest request)
{
// convert current route results
List <RouteResult> routeResults = new List <RouteResult>(
base.ConvertResult(vrpResult, request));
// add route results from previous solve for those routes that
// were not used in the last solve
List <RouteResult> prevRouteResults = new List <RouteResult>();
foreach (RouteResult rr in _prevRouteResults)
{
if (!_ContainsRoute(routeResults, rr.Route))
{
prevRouteResults.Add(rr);
}
}
routeResults.AddRange(prevRouteResults);
return(routeResults);
}
/// <summary>
/// Does nothing but returns boolean constant passed to the constructor.
/// </summary>
/// <param name="request">The reference to the request object to be
/// analyzed.</param>
/// <returns>A value passed to the constructor.</returns>
public bool CanExecuteSyncronously(SubmitVrpJobRequest request)
{
return(_executeSynchronously);
}
