/// <summary>Creates baseline forcing request context.</summary>
/// <param name="endpoint">The endpoint.</param>
/// <param name="elementId">Identifier for the element.</param>
/// <param name="requestId">Identifier for the request.</param>
/// <param name="sessionId">Identifier for the session.</param>
/// <param name="timeout">The timeout.</param>
/// <param name="commandType">Type of the command.</param>
/// <returns>The new baseline forcing request context.</returns>
public PIS.Ground.Core.Data.IRequestContext CreateBaselineForcingRequestContext(string endpoint, string elementId, Guid requestId, Guid sessionId, uint timeout, PIS.Ground.DataPackage.BaselineCommandType commandType)
{
BaselineForcingRequestContext requestContext = new BaselineForcingRequestContext(endpoint, elementId, requestId, sessionId, timeout, commandType);
IRequestContextProcessor requestProcessor = new BaselineForcingRequestContextProcessor();
requestContext.RequestProcessor = requestProcessor;
return(requestContext);
}
/// <summary>
/// Processes the requests.
/// </summary>
/// <param name="currentRequests">The request to process.</param>
protected virtual void ProcessRequests(List <IRequestContext> requests)
{
BaselineDistributingRequestContext processBaselineDistributingRequest = null;
for (int i = 0; i < requests.Count && !_stopTransmitThread; ++i)
{
IRequestContext request = requests[i];
switch (request.State)
{
case RequestState.Created:
Predicate <IRequestContext> comparisonPredicate;
if (request is BaselineDistributingRequestContext)
{
comparisonPredicate = c => { return(c is BaselineDistributingRequestContext && (string.Equals(c.ElementId, request.ElementId) && (c.RequestId != request.RequestId || c.RequestId == Guid.Empty))); };
}
else if (request is BaselineForcingRequestContext)
{
comparisonPredicate = c => { return(c is BaselineForcingRequestContext && (string.Equals(c.ElementId, request.ElementId) && (c.RequestId != request.RequestId || c.RequestId == Guid.Empty))); };
}
else
{
comparisonPredicate = c => { return(c is BaselineSettingRequestContext && (string.Equals(c.ElementId, request.ElementId) && (c.RequestId != request.RequestId || c.RequestId == Guid.Empty))); };
}
for (int j = requests.Count - 1; j >= 0; --j)
{
if (comparisonPredicate(requests[j]))
{
requests.RemoveAt(j);
if (j <= i)
{
--i;
}
}
}
break;
case RequestState.ReadyToSend:
break;
case RequestState.WaitingRetry:
break;
case RequestState.Expired:
BaselineForcingRequestContext processBaselineCommandRequest = request as BaselineForcingRequestContext;
if (null != processBaselineCommandRequest)
{
if (processBaselineCommandRequest.CommandType == BaselineCommandType.CLEAR_FORCING)
{
SendNotificationToGroundApp(
request.RequestId,
PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageBaselineClearForcingTimedOut,
FormatNotificationParameter(processBaselineCommandRequest.ElementId));
}
else
{
SendNotificationToGroundApp(
request.RequestId,
PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageBaselineForcingTimedOut,
FormatNotificationParameter(processBaselineCommandRequest.ElementId));
}
}
else
{
processBaselineDistributingRequest = request as BaselineDistributingRequestContext;
if (null != processBaselineDistributingRequest)
{
DataPackageService.deleteBaselineDistributingRequest(processBaselineDistributingRequest.ElementId);
SendNotificationToGroundApp(
request.RequestId,
PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageDistributionTimedOut,
FormatNotificationParameter(processBaselineDistributingRequest.ElementId, processBaselineDistributingRequest.BaselineVersion));
}
}
break;
case RequestState.Transmitted:
request.CompletionStatus = true;
processBaselineDistributingRequest = request as BaselineDistributingRequestContext;
if (null != processBaselineDistributingRequest)
{
DataPackageService.deleteBaselineDistributingRequest(processBaselineDistributingRequest.ElementId);
SendNotificationToGroundApp(
request.RequestId,
PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageDistributionTransferred,
FormatNotificationParameter(processBaselineDistributingRequest.ElementId, processBaselineDistributingRequest.BaselineVersion));
processBaselineDistributingRequest.CompletionStatus = true;
}
break;
case RequestState.AllRetriesExhausted:
break;
case RequestState.Completed:
break;
case RequestState.Error:
break;
}
}
if (!_stopTransmitThread)
{
requests.RemoveAll(c => c.IsStateFinal);
}
}
/// <summary>Process the force request described by request.</summary>
/// <exception cref="NotSupportedException">Thrown when the requested operation is not supported.</exception>
/// <param name="request">The request.</param>
private void ProcessForceRequest(IRequestContext request)
{
BaselineForcingRequestContext requestContext = request as BaselineForcingRequestContext;
if (requestContext == null)
{
throw new NotSupportedException("Can't process forcing baseline with a invalid request context.");
}
try
{
using (PIS.Ground.DataPackage.DataPackageTrainServiceClient lTrainDataPackageClient = new PIS.Ground.DataPackage.DataPackageTrainServiceClient("DataPackageEndpoint", requestContext.Endpoint))
{
try
{
string requestIdStr = requestContext.RequestId.ToString();
bool validCommand = true;
switch (requestContext.CommandType)
{
case BaselineCommandType.FORCE_FUTURE:
lTrainDataPackageClient.ForceFutureBaseline(requestIdStr);
break;
case BaselineCommandType.FORCE_ARCHIVED:
lTrainDataPackageClient.ForceArchivedBaseline(requestIdStr);
break;
case BaselineCommandType.CLEAR_FORCING:
lTrainDataPackageClient.CancelBaselineForcing(requestIdStr);
break;
default:
validCommand = false;
break;
}
if (validCommand)
{
if (requestContext.CommandType == BaselineCommandType.CLEAR_FORCING)
{
DataPackageService.sendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageBaselineClearForcingSent, request.ElementId);
}
else
{
DataPackageService.sendNotificationToGroundApp(request.RequestId, PIS.Ground.GroundCore.AppGround.NotificationIdEnum.DataPackageBaselineForcingSent, request.ElementId);
}
requestContext.TransmissionStatus = true;
requestContext.CompletionStatus = true;
}
}
catch (Exception ex)
{
if (false == requestContext.OnCommunicationError(ex))
{
requestContext.CompletionStatus = true;
}
}
finally
{
if (lTrainDataPackageClient.State == CommunicationState.Faulted)
{
lTrainDataPackageClient.Abort();
}
}
}
}
catch (Exception ex)
{
if (false == requestContext.OnCommunicationError(ex))
{
requestContext.CompletionStatus = true;
}
}
}
