/// <summary>
/// Start the application
/// </summary>
/// <param name="request">The start request.</param>
public void StartApplication(StartApplicationRequest request)
{
if (!Faulted)
{
_sender.StartApplication(request);
}
}
public async Task Then_ApplicationId_is_returned()
{
var request = new StartApplicationRequest
{
ApplicationId = ApplicationId,
CreatingContactId = UserId,
ApplySequences = new List <ApplySequence>
{
new ApplySequence
{
SequenceId = Guid.NewGuid(),
SequenceNo = 1,
Sections = new List <ApplySection>
{
new ApplySection
{
SectionId = Guid.NewGuid(),
SectionNo = 1
}
}
}
}
};
var result = await Handler.Handle(request, CancellationToken.None);
result.Should().Be(ApplicationId);
}
public void StartApplication(StartApplicationRequest request)
{
if (_proxy != null)
{
var rq = request as StartViewerApplicationRequest;
//_startRequest = request;
if (rq != null && rq.StudyInstanceUid.Count > 0)
{
Platform.Log(LogLevel.Info, "Sending Start Application request to server for Study: {0}", rq.StudyInstanceUid[0]);
}
else
{
Platform.Log(LogLevel.Info, "Sending Start Application request to server");
}
request.MetaInformation = new MetaInformation
{
Language = Thread.CurrentThread.CurrentUICulture.Name
};
_proxy.StartApplicationAsync(request);
}
else
{
Platform.Log(LogLevel.Error, "Request for Start Application when no proxy client was created");
}
}
internal static Application Start(StartApplicationRequest request)
{
var filter = new AttributeExtensionFilter(new ApplicationAttribute(request.GetType()));
var app = new ApplicationExtensionPoint().CreateExtension(filter) as IApplication;
if (app == null)
{
throw new NotSupportedException(String.Format("No application extension exists for start request type {0}", request.GetType().FullName));
}
if (!(app is Application))
{
throw new NotSupportedException("Application class must derive from Application base class.");
}
#region Setup
var application = (Application)app;
var context = new ApplicationContext(application);
application._context = context;
application._sessionPollingIntervalSeconds = TimeSpan.FromSeconds(ApplicationServiceSettings.Default.SessionPollingIntervalSeconds);
#endregion
//NOTE: must call start before adding to the cache; we want the app to be fully initialized before it can be accessed from outside this method.
application.InternalStart(request);
Cache.Instance.Add(application);
return(application);
}
public async Task <IActionResult> Post([FromBody] StartApplicationRequest request)
{
var command = new StartApplicationSaga
{
FirstName = request.FirstName,
LastName = request.LastName,
Email = request.Email,
Password = request.Password,
EligibilityQualifierId = request.EligibilityQualifierId,
ProductId = request.ProductId
};
var commandResponse = await _bus.SendCommand <StartApplicationSagaResponse>(command);
Log.Debug("Got response back from StartApplicationSaga");
Log.Debug("Attempting to get a token from the identity server at " + _identityClient.EndpointUri);
var authResult = await _identityClient.GetToken(request.Email, request.Password);
Log.Debug("Got a response from the Identity Server");
var response = new StartApplicationResponse
{
ApplicationId = commandResponse.ApplicationId,
FirstName = request.FirstName,
LastName = request.LastName,
Email = request.Email,
Token = authResult.AccessToken,
EligibilityQualifierId = request.EligibilityQualifierId,
ProductId = request.ProductId
};
return(OaoResult.Created(response.ApplicationId, response, commandResponse.Actions));
}
public async Task <StartApplicationResponse> StartApplications(StartApplicationRequest startAppRequest)
{
using (var request = new HttpRequestMessage(HttpMethod.Post, $"/applications/start"))
{
return(await PostPutRequestWithResponse <StartApplicationRequest, StartApplicationResponse>(request, startAppRequest));
}
}
internal StartApplicationResponse StartApplication(StartApplicationRequest request)
{
var marshaller = new StartApplicationRequestMarshaller();
var unmarshaller = StartApplicationResponseUnmarshaller.Instance;
return(Invoke <StartApplicationRequest, StartApplicationResponse>(request, marshaller, unmarshaller));
}
private async Task <CreateApplicationRequest> BuildRequest(StartApplicationRequest startApplicationRequest, string applicationType, Guid contactId, Guid organisationId, string referenceFormat)
{
var qnaResponse = await _qnaApiClient.StartApplications(startApplicationRequest);
var sequences = await _qnaApiClient.GetAllApplicationSequences(qnaResponse.ApplicationId);
var sections = sequences.Select(async sequence => await _qnaApiClient.GetSections(qnaResponse.ApplicationId, sequence.Id)).Select(t => t.Result).ToList();
return(new CreateApplicationRequest
{
ApplicationType = applicationType,
QnaApplicationId = qnaResponse.ApplicationId,
OrganisationId = organisationId,
ApplicationReferenceFormat = referenceFormat,
CreatingContactId = contactId,
ApplySequences = sequences.Select(sequence => new ApplySequence
{
SequenceId = sequence.Id,
Sections = sections.SelectMany(y => y.Where(x => x.SequenceNo == sequence.SequenceNo).Select(x => new ApplySection
{
SectionId = x.Id,
SectionNo = x.SectionNo,
Status = ApplicationSectionStatus.Draft,
RequestedFeedbackAnswered = x.QnAData.RequestedFeedbackAnswered
})).ToList(),
Status = ApplicationSequenceStatus.Draft,
IsActive = sequence.IsActive,
SequenceNo = sequence.SequenceNo,
NotRequired = sequence.NotRequired
}).ToList()
});
}
internal void InternalStart(StartApplicationRequest request)
{
try
{
ProcessMetaInfo(request.MetaInformation);
AuthenticateUser(request);
_synchronizationContext = new WebSynchronizationContext(this);
_synchronizationContext.Send(nothing => DoStart(request), null);
}
catch (Exception)
{
Logout();
DisposeMembers();
throw;
}
lock (_syncLock)
{
//DoStart can call Stop.
if (_stop)
{
return;
}
}
_timer = new System.Threading.Timer(OnTimer, null, TimerInterval, TimerInterval);
}
/// <summary>
/// Initiates the asynchronous execution of the StartApplication operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the StartApplication operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
public Task <StartApplicationResponse> StartApplicationAsync(StartApplicationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var marshaller = new StartApplicationRequestMarshaller();
var unmarshaller = StartApplicationResponseUnmarshaller.Instance;
return(InvokeAsync <StartApplicationRequest, StartApplicationResponse>(request, marshaller,
unmarshaller, cancellationToken));
}
/// <summary>
/// Initiates the asynchronous execution of the StartApplication operation.
/// </summary>
///
/// <param name="request">Container for the necessary parameters to execute the StartApplication operation.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
/// <returns>The task object representing the asynchronous operation.</returns>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/kinesisanalyticsv2-2018-05-23/StartApplication">REST API Reference for StartApplication Operation</seealso>
public virtual Task <StartApplicationResponse> StartApplicationAsync(StartApplicationRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = StartApplicationRequestMarshaller.Instance;
options.ResponseUnmarshaller = StartApplicationResponseUnmarshaller.Instance;
return(InvokeAsync <StartApplicationResponse>(request, options, cancellationToken));
}
internal virtual StartApplicationResponse StartApplication(StartApplicationRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = StartApplicationRequestMarshaller.Instance;
options.ResponseUnmarshaller = StartApplicationResponseUnmarshaller.Instance;
return(Invoke <StartApplicationResponse>(request, options));
}
public async Task <ActionResult> StartApplication([FromBody] StartApplicationRequest request)
{
var newApplicationResponse = await _mediator.Send(request);
if (!newApplicationResponse.Success)
{
_logger.LogError($"Unable to start application | Reason : {newApplicationResponse.Message}");
return(BadRequest(new BadRequestError(newApplicationResponse.Message)));
}
return(Ok(new { newApplicationResponse.Value.ApplicationId }));
}
public StartApplicationRequestResponse StartApplication(StartApplicationRequest request)
{
CheckNumberOfApplications();
CheckMemoryAvailable();
try
{
OperationContext operationContext = OperationContext.Current;
// 5 minute timeout, mostly for debugging.
operationContext.Channel.OperationTimeout = TimeSpan.FromMinutes(5);
Application application = Application.Start(request);
//TODO: when we start allowing application recovery, remove these lines.
// NOTE: These events are fired only if the underlying connection is permanent (eg, duplex http or net tcp).
// Commented out per CR 3/22/2011, don't want the contenxt to reference the application
//operationContext.Channel.Closed += delegate { application.Stop(); };
//operationContext.Channel.Faulted += delegate { application.Stop(); };
return(new StartApplicationRequestResponse {
AppIdentifier = application.Identifier
});
}
catch (Enterprise.Common.InvalidUserSessionException ex)
{
throw new FaultException <SessionValidationFault>(new SessionValidationFault {
ErrorMessage = ExceptionTranslator.Translate(ex)
});
}
catch (Enterprise.Common.PasswordExpiredException ex)
{
throw new FaultException <SessionValidationFault>(new SessionValidationFault {
ErrorMessage = ExceptionTranslator.Translate(ex)
});
}
catch (Enterprise.Common.UserAccessDeniedException ex)
{
throw new FaultException <SessionValidationFault>(new SessionValidationFault {
ErrorMessage = ExceptionTranslator.Translate(ex)
});
}
catch (Enterprise.Common.RequestValidationException ex)
{
throw new FaultException <SessionValidationFault>(new SessionValidationFault {
ErrorMessage = ExceptionTranslator.Translate(ex)
});
}
catch (Exception ex)
{
throw new FaultException(ExceptionTranslator.Translate(ex));
}
}
public async Task <IActionResult> StartApplication(PreviewViewModel previewViewModel)
{
if (!ModelState.IsValid)
{
return(View(previewViewModel));
}
var applicationStartRequest = new StartApplicationRequest
{
UserReference = UserReference,
WorkflowType = previewViewModel.ProjectType,
ApplicationData = previewViewModel.ApplicationData
};
var qnaResponse = new StartApplicationResponse();
try
{
qnaResponse = await _qnaApiClient.StartApplications(applicationStartRequest);
}
catch (HttpRequestException ex) {
dynamic obj = JToken.Parse(ex.Message);
if (obj.statusCode == "400")
{
ModelState.AddModelError(nameof(previewViewModel.ApplicationData), (string)obj.message);
return(View(previewViewModel));
}
}
if (_sessionService.Exists("viewPreviewData"))
{
_sessionService.Remove("viewPreviewData");
}
_sessionService.Set("viewPreviewData", JsonConvert.SerializeObject(previewViewModel));
var allApplicationSequences = await _qnaApiClient.GetAllApplicationSequences(qnaResponse.ApplicationId);
var sequenceNos = string.Join(',', allApplicationSequences.Select(x => x.SequenceNo));
foreach (var _ in allApplicationSequences.Where(seq => seq.SequenceNo == previewViewModel.SequenceNo).Select(seq => new { }))
{
var sections = allApplicationSequences.Select(async sequence => await _qnaApiClient.GetSections(qnaResponse.ApplicationId, sequence.Id)).Select(t => t.Result).ToList();
return(RedirectToAction("Sequence", new { Id = qnaResponse.ApplicationId, sequenceNo = previewViewModel.SequenceNo }));
}
ModelState.AddModelError(nameof(previewViewModel.SequenceNo), $"Sequence number not found. Valid sequences are: {sequenceNos}");
return(View(previewViewModel));
}
private async Task <Data.Entities.Application> CreateNewApplication(StartApplicationRequest request, Workflow latestWorkflow, CancellationToken cancellationToken, string applicationData)
{
var newApplication = new Data.Entities.Application
{
ApplicationStatus = ApplicationStatus.InProgress,
WorkflowId = latestWorkflow.Id,
Reference = request.UserReference,
CreatedAt = SystemTime.UtcNow(),
ApplicationData = applicationData
};
_dataContext.Applications.Add(newApplication);
_logger.LogInformation($"Created Application entity: {newApplication.Id}");
return(newApplication);
}
public async Task <HandlerResponse <StartApplicationResponse> > Handle(StartApplicationRequest request, CancellationToken cancellationToken)
{
var latestWorkflow = await _dataContext.Workflows.AsNoTracking()
.SingleOrDefaultAsync(w => w.Type == request.WorkflowType && w.Status == "Live", cancellationToken);
if (latestWorkflow is null)
{
_logger.LogError($"Workflow type {request.WorkflowType} does not exist");
return(new HandlerResponse <StartApplicationResponse>(false, $"Workflow Type does not exist."));
}
try
{
_applicationDataIsInvalid = !_applicationDataValidator.IsValid(latestWorkflow.ApplicationDataSchema, request.ApplicationData);
}
catch (JsonReaderException)
{
_logger.LogError("Supplied ApplicationData is not valid JSON");
return(new HandlerResponse <StartApplicationResponse>(false, $"Supplied ApplicationData is not valid JSON."));
}
if (_applicationDataIsInvalid)
{
_logger.LogError("Supplied ApplicationData is not valid using Project's Schema");
return(new HandlerResponse <StartApplicationResponse>(false, $"Supplied ApplicationData is not valid using Project's Schema."));
}
var newApplication = await CreateNewApplication(request, latestWorkflow, cancellationToken, request.ApplicationData);
if (newApplication is null)
{
_logger.LogError($"Workflow type {request.WorkflowType} does not exist");
return(new HandlerResponse <StartApplicationResponse>(false, $"WorkflowType '{request.WorkflowType}' does not exist."));
}
await CopyWorkflows(cancellationToken, newApplication);
await _dataContext.SaveChangesAsync(cancellationToken);
_logger.LogInformation($"Successfully created new Application. Application Id = {newApplication.Id} | Workflow = {request.WorkflowType}");
return(new HandlerResponse <StartApplicationResponse>(new StartApplicationResponse {
ApplicationId = newApplication.Id
}));
}
public async Task <CreateApplicationRequest> BuildInitialRequest(ContactResponse contact, OrganisationResponse organisation, string referenceFormat)
{
var startApplicationRequest = new StartApplicationRequest
{
UserReference = contact.Id.ToString(),
WorkflowType = WorkflowType,
ApplicationData = JsonConvert.SerializeObject(new ApplicationData
{
UseTradingName = false,
OrganisationName = organisation.EndPointAssessorName,
OrganisationReferenceId = organisation.Id.ToString(),
OrganisationType = organisation.OrganisationType,
CompanySummary = organisation.CompanySummary,
CharitySummary = organisation.CharitySummary
})
};
return(await BuildRequest(startApplicationRequest, ApplicationTypes.Initial, contact.Id, organisation.Id, referenceFormat));
}
private void AuthenticateUser(StartApplicationRequest request)
{
_userName = request.Username;
if (!String.IsNullOrEmpty(request.SessionId))
{
IsSessionShared = request.IsSessionShared;
}
_session = UserAuthentication.ValidateSession(request.Username, request.SessionId);
if (_session == null)
{
return;
}
if (_session.Principal != null)
{
Thread.CurrentPrincipal = Principal = _session.Principal;
}
}
private void DoStart(StartApplicationRequest request)
{
_context.FireEvent(new ApplicationStartedEvent
{
Identifier = Guid.NewGuid(),
SenderId = Identifier,
StartRequestId = request.Identifier
});
OnStart(request);
string logMessage = _session == null
? String.Format("Application {0} has started.", Identifier)
: String.Format("Application {0} has started (user={1}, session={2}, expiry={3}).",
Identifier, _userName, _session.SessionToken.Id,
_session.SessionToken.ExpiryTime);
ConsoleHelper.Log(LogLevel.Info, ConsoleColor.Green, logMessage);
OnSessionRenewed();
}
public void StartApplication(StartApplicationRequest request)
{
if (_proxy != null)
{
var rq = request as StartViewerApplicationRequest;
//_startRequest = request;
if (rq!=null && rq.StudyInstanceUid.Count > 0 )
Platform.Log(LogLevel.Info, "Sending Start Application request to server for Study: {0}",rq.StudyInstanceUid[0]);
else
Platform.Log(LogLevel.Info, "Sending Start Application request to server");
request.MetaInformation = new MetaInformation
{
Language = Thread.CurrentThread.CurrentUICulture.Name
};
_proxy.StartApplicationAsync(request);
}
else
{
Platform.Log(LogLevel.Error,"Request for Start Application when no proxy client was created");
}
}
public async Task <CreateApplicationRequest> BuildOrganisationWithdrawalRequest(ContactResponse contact, OrganisationResponse organisation, string referenceFormat)
{
var pipelinesCount = _learnerDetailsApiClient.GetPipelinesCount(organisation.EndPointAssessorOrganisationId, null);
var earliestWithdrawalDate = _organisationsApiClient.GetEarliestWithdrawalDate(organisation.Id, null);
await Task.WhenAll(pipelinesCount, earliestWithdrawalDate);
var startApplicationRequest = new StartApplicationRequest
{
UserReference = contact.Id.ToString(),
WorkflowType = WorkflowType,
ApplicationData = JsonConvert.SerializeObject(new ApplicationData
{
UseTradingName = false,
OrganisationName = organisation.EndPointAssessorName,
OrganisationReferenceId = organisation.Id.ToString(),
PipelinesCount = pipelinesCount.Result,
EarliestDateOfWithdrawal = earliestWithdrawalDate.Result
})
};
return(await BuildRequest(startApplicationRequest, ApplicationTypes.OrganisationWithdrawal, contact.Id, organisation.Id, referenceFormat));
}
public async Task <ActionResult <Guid> > Start([FromBody] StartApplicationRequest request)
{
return(await _mediator.Send(request));
}
public StartApplicationResponse StartApplication(StartApplicationRequest request)
{
throw new NotImplementedException();
}
public async Task <Guid> StartApplication(StartApplicationRequest startApplicationRequest)
{
return(await Post <StartApplicationRequest, Guid>($"/Application/Start", startApplicationRequest));
}
protected abstract void OnStart(StartApplicationRequest request);
public async Task <StartApplicationResponse> StartApplication(StartApplicationRequest request)
{
return(await HttpCall <StartApplicationResponse>(async() => await _httpClient.PostAsJsonAsync(new Uri("applications/start", UriKind.Relative), request)));
}
/// <summary>
/// Start the application
/// </summary>
/// <param name="request">The start request.</param>
public void StartApplication(StartApplicationRequest request)
{
if (!Faulted)
_sender.StartApplication(request);
}
protected override void OnStart(StartApplicationRequest request)
{
//NOOP
IsRunning = true;
}
public StartApplicationResponse StartApplication(StartApplicationRequest request)
{
throw new NotImplementedException();
}
void IApplication.Start(StartApplicationRequest request)
{
throw new InvalidOperationException("Start must be called internally.");
}
protected override void OnStart(StartApplicationRequest request)
{
lock (_syncLock)
{
Platform.Log(LogLevel.Info, "Viewer Application is starting...");
if (Application.Instance == null)
{
Platform.StartApp("ClearCanvas.Desktop.Application", new string[] { "-r" });
}
}
if (Platform.IsLogLevelEnabled(LogLevel.Debug))
{
Platform.Log(LogLevel.Debug, "Finding studies...");
}
var startRequest = (StartViewerApplicationRequest)request;
IList <StudyRootStudyIdentifier> studies = FindStudies(startRequest);
List <LoadStudyArgs> loadArgs = CollectionUtils.Map(studies, (StudyRootStudyIdentifier identifier) => CreateLoadStudyArgs(identifier));
DesktopWindowCreationArgs args = new DesktopWindowCreationArgs("", Identifier.ToString());
WebDesktopWindow window = new WebDesktopWindow(args, Application.Instance);
window.Open();
_viewer = CreateViewerComponent(startRequest);
try
{
if (Platform.IsLogLevelEnabled(LogLevel.Debug))
{
Platform.Log(LogLevel.Debug, "Loading study...");
}
_viewer.LoadStudies(loadArgs);
}
catch (Exception e)
{
if (!AnySopsLoaded(_viewer)) //end the app.
{
throw;
}
//Show an error and continue.
ExceptionHandler.Report(e, window);
}
if (Platform.IsLogLevelEnabled(LogLevel.Debug))
{
Platform.Log(LogLevel.Info, "Launching viewer...");
}
ImageViewerComponent.Launch(_viewer, window, "");
_viewerHandler = EntityHandler.Create <ViewerEntityHandler>();
_viewerHandler.SetModelObject(_viewer);
_app = new Common.ViewerApplication
{
Identifier = Identifier,
Viewer = (Viewer)_viewerHandler.GetEntity(),
VersionString = GetProductVersionString()
};
// Push the ViewerApplication object to the client
Event @event = new PropertyChangedEvent
{
PropertyName = "Application",
Value = _app,
Identifier = Guid.NewGuid(),
SenderId = request.Identifier
};
ApplicationContext.Current.FireEvent(@event);
}
