public async Task <IActionResult> CompleteAndSendIn(string org, string service, int instanceId, string view) { // Dependency Injection: Getting the Service Specific Implementation based on the service parameter data store // Will compile code and load DLL in to memory for AltinnCore IServiceImplementation serviceImplementation = _execution.GetServiceImplementation(org, service, false); // Get the serviceContext containing all metadata about current service ServiceContext serviceContext = _execution.GetServiceContext(org, service, false); // Create and populate the RequestContext object and make it available for the service implementation so // service developer can implement logic based on information about the request and the user performing // the request RequestContext requestContext = PopulateRequestContext(instanceId); PlatformServices platformServices = new PlatformServices(_authorization, _repository, _execution, org, service); serviceImplementation.SetPlatformServices(platformServices); // Assign data to the ViewBag so it is available to the service views or service implementation PopulateViewBag(org, service, instanceId, 0, requestContext, serviceContext, platformServices); // Getting the Form Data from database object serviceModel = _form.GetFormModel(instanceId, serviceImplementation.GetServiceModelType(), org, service, requestContext.UserContext.ReporteeId, AuthenticationHelper.GetDeveloperUserName(_httpContextAccessor.HttpContext)); serviceImplementation.SetServiceModel(serviceModel); ViewBag.FormID = instanceId; ViewBag.ServiceContext = serviceContext; serviceImplementation.SetContext(requestContext, ViewBag, serviceContext, null, ModelState); await serviceImplementation.RunServiceEvent(ServiceEventType.Validation); ApiResult apiResult = new ApiResult(); if (ModelState.IsValid) { ServiceState currentState = _workflowSI.MoveServiceForwardInWorkflow(instanceId, org, service, requestContext.UserContext.ReporteeId); if (currentState.State == WorkflowStep.Archived) { _archive.ArchiveServiceModel(serviceModel, instanceId, serviceImplementation.GetServiceModelType(), org, service, requestContext.UserContext.ReporteeId); apiResult.NextState = currentState.State; } } ModelHelper.MapModelStateToApiResult(ModelState, apiResult, serviceContext); if (apiResult.Status.Equals(ApiStatusType.ContainsError)) { Response.StatusCode = 202; } else { Response.StatusCode = 200; } return(new ObjectResult(apiResult)); }
private async Task <ActionResult> PutFormData(string org, string app, Instance instance, Guid dataGuid, string elementType) { Guid instanceGuid = Guid.Parse(instance.Id.Split("/")[1]); IServiceImplementation serviceImplementation = await PrepareServiceImplementation(org, app, elementType); object serviceModel = ParseContentAndDeserializeServiceModel(serviceImplementation.GetServiceModelType(), out ActionResult contentError); if (contentError != null) { return(contentError); } if (serviceModel == null) { return(BadRequest("No data found in content")); } serviceImplementation.SetServiceModel(serviceModel); // send events to trigger application business logic await serviceImplementation.RunServiceEvent(ServiceEventType.DataRetrieval); await serviceImplementation.RunServiceEvent(ServiceEventType.Calculation); try { // Run the model Validation that handles validation defined on the model TryValidateModel(serviceModel); // send events to trigger application business logic await serviceImplementation.RunServiceEvent(ServiceEventType.Validation); } catch (Exception ex) { logger.LogError($"Validation errors are currently ignored: {ex.Message}"); } // Save Formdata to database Instance instanceAfter = await this.dataService.UpdateData( serviceModel, instanceGuid, serviceImplementation.GetServiceModelType(), org, app, int.Parse(instance.InstanceOwnerId), dataGuid); InstancesController.SetAppSelfLinks(instanceAfter, Request); DataElement updatedElement = instanceAfter.Data.First(d => d.Id == dataGuid.ToString()); string dataUrl = updatedElement.DataLinks.Apps; return(Created(dataUrl, updatedElement)); }
/// <summary> /// Validate the model. /// </summary> /// <param name="org">the organisation.</param> /// <param name="service">the service.</param> /// <param name="instanceId">the instance id.</param> /// <returns>The api response.</returns> public async Task <IActionResult> ModelValidation(string org, string service, Guid instanceId) { // Dependency Injection: Getting the Service Specific Implementation based on the service parameter data store // Will compile code and load DLL in to memory for AltinnCore IServiceImplementation serviceImplementation = _execution.GetServiceImplementation(org, service, false); // Create and populate the RequestContext object and make it available for the service implementation so // service developer can implement logic based on information about the request and the user performing // the request RequestContext requestContext = RequestHelper.GetRequestContext(Request.Query, instanceId); requestContext.UserContext = await _userHelper.GetUserContext(HttpContext); requestContext.Reportee = requestContext.UserContext.Reportee; requestContext.Form = Request.Form; // Get the serviceContext containing all metadata about current service ServiceContext serviceContext = _execution.GetServiceContext(org, service, false); // Assign the Requestcontext and ViewBag to the serviceImplementation so // service developer can use the information in any of the service events that is called serviceImplementation.SetContext(requestContext, serviceContext, null, ModelState); // Set the platform services to the ServiceImplementation so the AltinnCore service can take // use of the plattform services serviceImplementation.SetPlatformServices(_platformSI); // Getting the populated form data from disk dynamic serviceModel = _form.GetFormModel( instanceId, serviceImplementation.GetServiceModelType(), org, service, requestContext.UserContext.ReporteeId, AuthenticationHelper.GetDeveloperUserName(_httpContextAccessor.HttpContext)); serviceImplementation.SetServiceModel(serviceModel); // Do Model Binding and update form data await TryUpdateModelAsync(serviceModel); // ServiceEvent : HandleValidationEvent // Perform Validation defined by the service developer. await serviceImplementation.RunServiceEvent(ServiceEventType.Validation); ApiResult apiResult = new ApiResult(); ModelHelper.MapModelStateToApiResult(ModelState, apiResult, serviceContext); if (apiResult.Status.Equals(ApiStatusType.ContainsError)) { Response.StatusCode = 202; } else { Response.StatusCode = 200; } return(new ObjectResult(apiResult)); }
/// <summary> /// Action method to present. /// </summary> /// <param name="org">The Organization code for the service owner.</param> /// <param name="service">The service code for the current service.</param> /// <param name="partyId">The partyId.</param> /// <param name="instanceGuid">The instanceGuid.</param> /// <returns>The receipt view.</returns> public async Task <IActionResult> Receipt(string org, string service, int partyId, Guid instanceGuid) { // Dependency Injection: Getting the Service Specific Implementation based on the service parameter data store // Will compile code and load DLL in to memory for AltinnCore IServiceImplementation serviceImplementation = _execution.GetServiceImplementation(org, service, false); // Get the serviceContext containing all metadata about current service ServiceContext serviceContext = _execution.GetServiceContext(org, service, false); // Create and populate the RequestContext object and make it available for the service implementation so // service developer can implement logic based on information about the request and the user performing // the request RequestContext requestContext = RequestHelper.GetRequestContext(Request.Query, instanceGuid); requestContext.UserContext = await _userHelper.GetUserContext(HttpContext); requestContext.Party = requestContext.UserContext.Party; serviceImplementation.SetPlatformServices(_platformSI); // Assign data to the ViewBag so it is available to the service views or service implementation PopulateViewBag(org, service, instanceGuid, 0, requestContext, serviceContext, _platformSI); object serviceModel = _archive.GetArchivedServiceModel(instanceGuid, serviceImplementation.GetServiceModelType(), org, service, requestContext.Party.PartyId); List <ServiceInstance> formInstances = _testdata.GetFormInstances(requestContext.Party.PartyId, org, service); string properInstanceId = $"{requestContext.Party}/{instanceGuid}"; ViewBag.ServiceInstance = formInstances.Find(i => i.ServiceInstanceID == properInstanceId); return(View()); }
/// <summary> /// Gets a data element (form data) from storage and performs business logic on it (e.g. to calculate certain fields) before it is returned. /// If more there are more data elements of the same elementType only the first one is returned. In that case use the more spesific /// GET method to fetch a particular data element. /// </summary> /// <returns>data element is returned in response body</returns> private async Task <ActionResult> GetFormData( string org, string app, int instanceOwnerId, Guid instanceGuid, Guid dataGuid, string elementType) { IServiceImplementation serviceImplementation = await PrepareServiceImplementation(org, app, elementType); // Get Form Data from data service. Assumes that the data element is form data. object serviceModel = dataService.GetFormData( instanceGuid, serviceImplementation.GetServiceModelType(), org, app, instanceOwnerId, dataGuid); if (serviceModel == null) { return(BadRequest($"Did not find form data for data element {dataGuid}")); } // Assing the populated service model to the service implementation serviceImplementation.SetServiceModel(serviceModel); // send events to trigger application business logic await serviceImplementation.RunServiceEvent(ServiceEventType.DataRetrieval); await serviceImplementation.RunServiceEvent(ServiceEventType.Calculation); return(Ok(serviceModel)); }
private async Task <Instance> StorePrefillParts(Instance instance, List <RequestPart> parts) { Guid instanceGuid = Guid.Parse(instance.Id.Split("/")[1]); int instanceOwnerIdAsInt = int.Parse(instance.InstanceOwnerId); Instance instanceWithData = null; string org = instance.Org; string app = instance.AppId.Split("/")[1]; foreach (RequestPart part in parts) { logger.LogInformation($"Storing part {part.Name}"); object data = new StreamReader(part.Stream).ReadToEnd(); IServiceImplementation serviceImplementation = await PrepareServiceImplementation(org, app, part.Name, true); instanceWithData = await dataService.InsertFormData( data, instanceGuid, serviceImplementation.GetServiceModelType(), org, app, instanceOwnerIdAsInt); if (instanceWithData == null) { throw new InvalidOperationException($"Dataservice did not return a valid instance metadata when attempt to store data element {part.Name}"); } } return(instanceWithData); }
public async Task <IActionResult> CompleteAndSendIn(string org, string service, Guid instanceId) { // Dependency Injection: Getting the Service Specific Implementation based on the service parameter data store // Will compile code and load DLL in to memory for AltinnCore IServiceImplementation serviceImplementation = _execution.GetServiceImplementation(org, service, false); // Create and populate the RequestContext object and make it available for the service implementation so // service developer can implement logic based on information about the request and the user performing // the request RequestContext requestContext = RequestHelper.GetRequestContext(Request.Query, instanceId); requestContext.UserContext = await _userHelper.GetUserContext(HttpContext); requestContext.Reportee = requestContext.UserContext.Reportee; // Get the serviceContext containing all metadata about current service ServiceContext serviceContext = _execution.GetServiceContext(org, service, false); serviceImplementation.SetPlatformServices(_platformSI); // Identify the correct view // Getting the Form Data from database object serviceModel = _form.GetFormModel(instanceId, serviceImplementation.GetServiceModelType(), org, service, requestContext.UserContext.ReporteeId, AuthenticationHelper.GetDeveloperUserName(_httpContextAccessor.HttpContext)); serviceImplementation.SetServiceModel(serviceModel); serviceImplementation.SetContext(requestContext, serviceContext, null, ModelState); ViewBag.FormID = instanceId; ViewBag.ServiceContext = serviceContext; await serviceImplementation.RunServiceEvent(ServiceEventType.Validation); return(View()); }
/// <summary> /// Action method to present. /// </summary> /// <param name="org">The Organization code for the service owner.</param> /// <param name="service">The service code for the current service.</param> /// <param name="instanceId">The instanceId.</param> /// <returns>The receipt view.</returns> public IActionResult Receipt(string org, string service, int instanceId) { // Dependency Injection: Getting the Service Specific Implementation based on the service parameter data store // Will compile code and load DLL in to memory for AltinnCore IServiceImplementation serviceImplementation = _execution.GetServiceImplementation(org, service, false); // Get the serviceContext containing all metadata about current service ServiceContext serviceContext = _execution.GetServiceContext(org, service, false); // Create and populate the RequestContext object and make it available for the service implementation so // service developer can implement logic based on information about the request and the user performing // the request RequestContext requestContext = RequestHelper.GetRequestContext(Request.Query, instanceId); requestContext.UserContext = _userHelper.GetUserContext(HttpContext); requestContext.Reportee = requestContext.UserContext.Reportee; PlatformServices platformServices = new PlatformServices(_authorization, _repository, _execution, org, service); serviceImplementation.SetPlatformServices(platformServices); // Assign data to the ViewBag so it is available to the service views or service implementation PopulateViewBag(org, service, instanceId, 0, requestContext, serviceContext, platformServices); object serviceModel = _archive.GetArchivedServiceModel(instanceId, serviceImplementation.GetServiceModelType(), org, service, requestContext.Reportee.PartyId); List <ServiceInstance> formInstances = _testdata.GetFormInstances(requestContext.Reportee.PartyId, org, service, AuthenticationHelper.GetDeveloperUserName(_httpContextAccessor.HttpContext)); ViewBag.ServiceInstance = formInstances.Find(i => i.ServiceInstanceID == instanceId); return(View()); }
public async Task <IActionResult> Index(string org, string service, string edition, int instanceId) { // Getting the Service Specific Implementation contained in external DLL migrated from TUL IServiceImplementation serviceImplementation = _execution.GetServiceImplementation(org, service, edition); // Create and populate the RequestContext object and make it available for the service implementation so // service developer can implement logic based on information about the request and the user performing // the request RequestContext requestContext = RequestHelper.GetRequestContext(Request.Query, instanceId); requestContext.UserContext = _userHelper.GetUserContext(HttpContext); requestContext.Reportee = requestContext.UserContext.Reportee; // Get the serviceContext containing all metadata about current service ServiceContext serviceContext = _execution.GetServiceContext(org, service, edition); // Assign data to the ViewBag so it is available to the service views or service implementation ViewBag.ServiceContext = serviceContext; ViewBag.RequestContext = requestContext; ViewBag.Org = org; ViewBag.Service = service; ViewBag.Edition = edition; ViewBag.FormID = instanceId; // Assign the RequestContext and ViewBag to the serviceImplementation so // service developer can use the information in any of the service events that is called serviceImplementation.SetContext(requestContext, ViewBag, serviceContext, null, ModelState); // Set the platform services to the ServiceImplementation so the AltinnCore service can take // use of the plattform services PlatformServices platformServices = new PlatformServices(_authorization, _repository, _execution, org, service, edition); serviceImplementation.SetPlatformServices(platformServices); ViewBag.PlatformServices = platformServices; // Getting the Form Data from datastore object serviceModel = this._form.GetFormModel( instanceId, serviceImplementation.GetServiceModelType(), org, service, edition, requestContext.UserContext.ReporteeId); // Assing the populated service model to the service implementation serviceImplementation.SetServiceModel(serviceModel); // ServiceEvent 1: HandleGetDataEvent // Runs the event where the service developer can implement functionality to retrieve data from internal/external sources // based on the data in the service model await serviceImplementation.RunServiceEvent(AltinnCore.ServiceLibrary.Enums.ServiceEventType.DataRetrieval); // ServiceEvent 2: HandleCalculationEvent // Perform Calculation defined by the service developer await serviceImplementation.RunServiceEvent(AltinnCore.ServiceLibrary.Enums.ServiceEventType.Calculation); return(Ok(serviceModel)); }
public async Task <ActionResult> CreateDataElement( [FromRoute] string org, [FromRoute] string app, [FromRoute] int instanceOwnerId, [FromRoute] Guid instanceGuid, [FromQuery] string elementType = "default") { bool startService = true; IServiceImplementation serviceImplementation = await PrepareServiceImplementation(org, app, elementType, startService); Application application = repositoryService.GetApplication(org, app); if (application != null) { return(NotFound($"AppId {org}/{app} was not found")); } Instance instanceBefore = await instanceService.GetInstance(app, org, instanceOwnerId, instanceGuid); if (instanceBefore == null) { return(BadRequest("Unknown instance")); } object serviceModel = null; if (Request.ContentType == null) { serviceModel = serviceImplementation.CreateNewServiceModel(); } else { serviceModel = ParseContentAndDeserializeServiceModel(serviceImplementation.GetServiceModelType(), out ActionResult contentError); if (contentError != null) { return(contentError); } } serviceImplementation.SetServiceModel(serviceModel); // send events to trigger application business logic await serviceImplementation.RunServiceEvent(ServiceEventType.Instantiation); await serviceImplementation.RunServiceEvent(ServiceEventType.ValidateInstantiation); InstancesController.SetAppSelfLinks(instanceBefore, Request); Instance instanceAfter = await dataService.InsertData(serviceModel, instanceGuid, serviceImplementation.GetServiceModelType(), org, app, instanceOwnerId); InstancesController.SetAppSelfLinks(instanceAfter, Request); List <DataElement> createdElements = CompareAndReturnCreatedElements(instanceBefore, instanceAfter); string dataUrl = createdElements.First().DataLinks.Apps; return(Created(dataUrl, instanceAfter)); }
public async Task <IActionResult> CompleteAndSendIn(string org, string service, string edition, int instanceId, string view) { // Dependency Injection: Getting the Service Specific Implementation based on the service parameter data store // Will compile code and load DLL in to memory for AltinnCore IServiceImplementation serviceImplementation = _execution.GetServiceImplementation(org, service, edition); // Get the serviceContext containing all metadata about current service ServiceContext serviceContext = _execution.GetServiceContext(org, service, edition); // Create and populate the RequestContext object and make it available for the service implementation so // service developer can implement logic based on information about the request and the user performing // the request RequestContext requestContext = PopulateRequestContext(instanceId); PlatformServices platformServices = new PlatformServices(_authorization, _repository, _execution, org, service, edition); serviceImplementation.SetPlatformServices(platformServices); // Assign data to the ViewBag so it is available to the service views or service implementation PopulateViewBag(org, service, edition, instanceId, 0, requestContext, serviceContext, platformServices); //Getting the Form Data from database object serviceModel = _form.GetFormModel(instanceId, serviceImplementation.GetServiceModelType(), org, service, edition, requestContext.UserContext.ReporteeId); serviceImplementation.SetServiceModel(serviceModel); ViewBag.FormID = instanceId; ViewBag.ServiceContext = serviceContext; serviceImplementation.SetContext(requestContext, ViewBag, serviceContext, null, ModelState); await serviceImplementation.RunServiceEvent(ServiceEventType.Validation); if (ModelState.IsValid) { _archive.ArchiveServiceModel(serviceModel, instanceId, serviceImplementation.GetServiceModelType(), org, service, edition, requestContext.UserContext.ReporteeId); return(RedirectToAction("Receipt", new { org, service, edition, instanceId })); } return(View()); }
/// <inheritdoc/> public async Task <Instance> InstantiateInstance(StartServiceModel startServiceModel, object serviceModel, IServiceImplementation serviceImplementation) { Guid instanceGuid = Guid.NewGuid(); string appName = startServiceModel.Service; string org = startServiceModel.Org; int instanceOwnerId = startServiceModel.PartyId; int userId = startServiceModel.UserId; ServiceState currentTask = _workflow.GetInitialServiceState(org, appName); Instance instance = new Instance { Id = $"{instanceOwnerId}/{instanceGuid}", InstanceOwnerId = instanceOwnerId.ToString(), AppId = $"{org}/{appName}", Org = org, CreatedBy = userId.ToString(), CreatedDateTime = DateTime.UtcNow, Process = new Storage.Interface.Models.ProcessState() { CurrentTask = currentTask.State.ToString(), IsComplete = false, }, InstanceState = new Storage.Interface.Models.InstanceState() { IsArchived = false, IsDeleted = false, IsMarkedForHardDelete = false, }, LastChangedDateTime = DateTime.UtcNow, LastChangedBy = userId.ToString(), }; string developer = AuthenticationHelper.GetDeveloperUserName(_httpContextAccessor.HttpContext); string testDataForParty = $"{_settings.GetTestdataForPartyPath(org, appName, developer)}{instanceOwnerId}"; string folderForInstance = Path.Combine(testDataForParty, instanceGuid.ToString()); Directory.CreateDirectory(folderForInstance); string instanceFilePath = $"{testDataForParty}/{instanceGuid}/{instanceGuid}.json"; File.WriteAllText(instanceFilePath, JsonConvert.SerializeObject(instance).ToString(), Encoding.UTF8); // Save instantiated form model instance = await _data.InsertData( serviceModel, instanceGuid, serviceImplementation.GetServiceModelType(), org, appName, instanceOwnerId); return(instance); }
public async Task <ActionResult> GetDataElement( [FromRoute] string org, [FromRoute] string app, [FromRoute] int instanceOwnerId, [FromRoute] Guid instanceGuid, [FromRoute] string elementType = "default") { IServiceImplementation serviceImplementation = await PrepareServiceImplementation(org, app, elementType); Instance instance = await instanceService.GetInstance(app, org, instanceOwnerId, instanceGuid); if (instance == null) { return(NotFound("Did not find instance")); } // Assume that there is only one data element of a given type !! DataElement dataElement = instance.Data.Find(m => m.ElementType.Equals(elementType)); if (dataElement == null) { return(NotFound("Did not find data element")); } Guid dataId = Guid.Parse(dataElement.Id); // Get Form Data from data service. Assumes that the data element is form data. object serviceModel = dataService.GetFormData( instanceGuid, serviceImplementation.GetServiceModelType(), org, app, instanceOwnerId, dataId); if (serviceModel == null) { return(BadRequest($"Did not find form data for data element {dataId}")); } // Assing the populated service model to the service implementation serviceImplementation.SetServiceModel(serviceModel); // send events to trigger application business logic await serviceImplementation.RunServiceEvent(AltinnCore.ServiceLibrary.Enums.ServiceEventType.DataRetrieval); await serviceImplementation.RunServiceEvent(AltinnCore.ServiceLibrary.Enums.ServiceEventType.Calculation); return(Ok(serviceModel)); }
/// <inheritdoc /> public async Task <Instance> InstantiateInstance(StartServiceModel startServiceModel, object serviceModel, IServiceImplementation serviceImplementation) { Guid instanceId; Instance instance = null; string org = startServiceModel.Org; string appId = ApplicationHelper.GetFormattedApplicationId(org, startServiceModel.Service); string appName = startServiceModel.Service; int instanceOwnerId = startServiceModel.PartyId; string apiUrl = $"instances/?appId={appId}&instanceOwnerId={instanceOwnerId}"; string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _cookieOptions.Cookie.Name); JwtTokenUtil.AddTokenToRequestHeader(_client, token); try { HttpResponseMessage response = await _client.PostAsync(apiUrl, new StringContent("{}", Encoding.UTF8, "application/json")); Instance createdInstance = await response.Content.ReadAsAsync <Instance>(); instanceId = Guid.Parse(createdInstance.Id.Split("/")[1]); } catch { return(instance); } // Save instantiated form model instance = await _data.InsertData( serviceModel, instanceId, serviceImplementation.GetServiceModelType(), org, appName, instanceOwnerId); ServiceState currentState = _workflow.GetInitialServiceState(org, appName); // set initial workflow state instance.Process = new Storage.Interface.Models.ProcessState() { CurrentTask = currentState.State.ToString(), IsComplete = false, }; instance = await UpdateInstance(instance, appName, org, instanceOwnerId, instanceId); return(instance); }
public async Task <IActionResult> Lookup([FromBody] AltinnCoreApiModel model, string reportee, string org, string service, string edition) { ApiResult apiResult = new ApiResult(); // Load the service implementation for the requested service IServiceImplementation serviceImplementation = _execution.GetServiceImplementation(org, service, edition); // Get the service context containing metadata about the service ServiceContext serviceContext = _execution.GetServiceContext(org, service, edition); // Create and populate the RequestContext object and make it available for the service implementation so // service developer can implement logic based on information about the request and the user performing // the request RequestContext requestContext = RequestHelper.GetRequestContext(Request.Query, 0); requestContext.UserContext = _userHelper.GetUserContext(HttpContext); requestContext.Reportee = requestContext.UserContext.Reportee; // Create platform service and assign to service implementation making it possible for the service implementation // to use plattform services. Also make it avaiable in ViewBag so it can be used from Views PlatformServices platformServices = new PlatformServices(_authorization, _repository, _execution, org, service, edition); serviceImplementation.SetPlatformServices(platformServices); ViewBag.PlatformServices = platformServices; // Create a new instance of the service model (a Get to lookup will always create a new service model) dynamic serviceModel = null; // Assign the different context information to the service implementation making it possible for // the service developer to take use of this information serviceImplementation.SetContext(requestContext, ViewBag, serviceContext, null, ModelState); // Do Model Binding and update form data serviceModel = ParseApiBody(serviceImplementation.GetServiceModelType(), out apiResult, model); if (serviceModel == null) { Response.StatusCode = 403; return(new ObjectResult(apiResult)); } serviceImplementation.SetServiceModel(serviceModel); // Run the Data Retriavel event where service developer can potensial load any data without any user input await serviceImplementation.RunServiceEvent(AltinnCore.ServiceLibrary.Enums.ServiceEventType.DataRetrieval); return(Ok(serviceModel)); }
/// <inheritdoc /> public async Task <Instance> InstantiateInstance(StartServiceModel startServiceModel, object serviceModel, IServiceImplementation serviceImplementation) { Guid instanceId; Instance instance = null; string applicationOwnerId = startServiceModel.Org; string applicationId = ApplicationHelper.GetFormattedApplicationId(applicationOwnerId, startServiceModel.Service); int instanceOwnerId = startServiceModel.ReporteeID; using (HttpClient client = new HttpClient()) { string apiUrl = $"{_platformSettings.GetApiStorageEndpoint}instances/?applicationId={applicationId}&instanceOwnerId={instanceOwnerId}"; client.BaseAddress = new Uri(apiUrl); client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json")); try { HttpResponseMessage response = await client.PostAsync(apiUrl, null); string id = await response.Content.ReadAsAsync <string>(); instanceId = Guid.Parse(id); } catch { return(instance); } } // Save instantiated form model instance = await _data.InsertData( serviceModel, instanceId, serviceImplementation.GetServiceModelType(), applicationOwnerId, applicationId, instanceOwnerId); ServiceState currentState = _workflow.GetInitialServiceState(applicationOwnerId, applicationId); // set initial workflow state instance.CurrentWorkflowStep = currentState.State.ToString(); instance = await UpdateInstance(instance, applicationId, applicationOwnerId, instanceOwnerId, instanceId); return(instance); }
public async Task <Instance> InstantiateInstance(StartServiceModel startServiceModel, object serviceModel, IServiceImplementation serviceImplementation) { Guid instanceId; Instance instance = null; string org = startServiceModel.Org; string app = startServiceModel.Service; int instanceOwnerId = startServiceModel.PartyId; Instance instanceTemplate = new Instance() { InstanceOwnerId = instanceOwnerId.ToString(), Process = new ProcessState() { Started = DateTime.UtcNow, CurrentTask = new ProcessElementInfo { Started = DateTime.UtcNow, ElementId = _workflow.GetInitialServiceState(org, app).State.ToString(), } }, }; Instance createdInstance = await CreateInstance(org, app, instanceTemplate); if (createdInstance == null) { return(null); } instanceId = Guid.Parse(createdInstance.Id.Split("/")[1]); // Save instantiated form model instance = await _data.InsertFormData( serviceModel, instanceId, serviceImplementation.GetServiceModelType(), org, app, instanceOwnerId); instance = await UpdateInstance(instance, app, org, instanceOwnerId, instanceId); return(instance); }
private async Task <ActionResult> CreateFormData( string org, string app, Instance instanceBefore, string elementType) { bool startService = true; Guid instanceGuid = Guid.Parse(instanceBefore.Id.Split("/")[1]); IServiceImplementation serviceImplementation = await PrepareServiceImplementation(org, app, elementType, startService); object serviceModel; if (Request.ContentType == null) { serviceModel = serviceImplementation.CreateNewServiceModel(); } else { serviceModel = ParseContentAndDeserializeServiceModel(serviceImplementation.GetServiceModelType(), out ActionResult contentError); if (contentError != null) { return(contentError); } } serviceImplementation.SetServiceModel(serviceModel); // send events to trigger application business logic await serviceImplementation.RunServiceEvent(ServiceEventType.Instantiation); await serviceImplementation.RunServiceEvent(ServiceEventType.ValidateInstantiation); InstancesController.SetAppSelfLinks(instanceBefore, Request); Instance instanceAfter = await dataService.InsertFormData(serviceModel, instanceGuid, serviceImplementation.GetServiceModelType(), org, app, int.Parse(instanceBefore.InstanceOwnerId)); InstancesController.SetAppSelfLinks(instanceAfter, Request); List <DataElement> createdElements = CompareAndReturnCreatedElements(instanceBefore, instanceAfter); string dataUrl = createdElements.First().DataLinks.Apps; return(Created(dataUrl, createdElements)); }
/// <summary> /// This method creates new instance in database /// </summary> public async Task <Guid> InstantiateInstance(StartServiceModel startServiceModel, object serviceModel, IServiceImplementation serviceImplementation) { Guid instanceId; string applicationId = startServiceModel.Service; string applicationOwnerId = startServiceModel.Org; int instanceOwnerId = startServiceModel.ReporteeID; using (HttpClient client = new HttpClient()) { string apiUrl = $"{_platformStorageSettings.ApiUrl}/instances/?applicationId={applicationId}&instanceOwnerId={instanceOwnerId}"; client.BaseAddress = new Uri(apiUrl); client.DefaultRequestHeaders.Accept.Clear(); client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json")); try { HttpResponseMessage response = await client.PostAsync(apiUrl, null); string id = await response.Content.ReadAsAsync <string>(); instanceId = Guid.Parse(id); } catch { return(Guid.Parse(string.Empty)); } } // Save instantiated form model Instance instance = await _data.InsertData( serviceModel, instanceId, serviceImplementation.GetServiceModelType(), applicationOwnerId, applicationId, instanceOwnerId); return(instanceId); }
/// <summary> /// Generates a new service instanceID for a service. /// </summary> /// <returns>A new instanceId.</returns> public async Task <Guid> InstantiateInstance(StartServiceModel startServiceModel, object serviceModel, IServiceImplementation serviceImplementation) { Guid instanceId = Guid.NewGuid(); string applicationId = startServiceModel.Service; string applicationOwnerId = startServiceModel.Org; int instanceOwnerId = startServiceModel.ReporteeID; Instance instance = new Instance { Id = instanceId.ToString(), InstanceOwnerId = instanceOwnerId.ToString(), ApplicationId = applicationId, CreatedBy = instanceOwnerId, CreatedDateTime = DateTime.UtcNow, }; string developer = AuthenticationHelper.GetDeveloperUserName(_httpContextAccessor.HttpContext); string apiUrl = $"{_settings.GetRuntimeAPIPath(SaveInstanceMethod, applicationOwnerId, applicationId, developer, instanceOwnerId)}&instanceId={instanceId}"; using (HttpClient client = AuthenticationHelper.GetDesignerHttpClient(_httpContextAccessor.HttpContext, _testdataRepositorySettings.GetDesignerHost())) { client.BaseAddress = new Uri(apiUrl); using (MemoryStream stream = new MemoryStream()) { var jsonData = JsonConvert.SerializeObject(instance); StreamWriter writer = new StreamWriter(stream); writer.Write(jsonData); writer.Flush(); stream.Position = 0; Task <HttpResponseMessage> response = client.PostAsync(apiUrl, new StreamContent(stream)); if (!response.Result.IsSuccessStatusCode) { throw new Exception("Unable to save instance"); } } } // Save instantiated form model Guid dataId = await _form.SaveFormModel( serviceModel, instanceId, serviceImplementation.GetServiceModelType(), applicationOwnerId, applicationId, instanceOwnerId, Guid.Empty); // Update instance with dataId instance = await GetInstance(applicationId, applicationOwnerId, instanceOwnerId, instanceId); Data data = new Data { Id = dataId.ToString(), ContentType = "application/Xml", StorageUrl = "data/boatdata/", CreatedBy = instanceOwnerId.ToString(), }; Dictionary <string, Data> formData = new Dictionary <string, Data>(); formData.Add(dataId.ToString(), data); instance.Data = new Dictionary <string, Dictionary <string, Data> >(); instance.Data.Add("boatData", formData); await UpdateInstance(instance, applicationId, applicationOwnerId, instanceOwnerId, instanceId); return(instanceId); }
public async Task <IActionResult> Index([FromBody] AltinnCoreApiModel model, string org, string service, string edition, int instanceId, ApiMode apiMode) { Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); ApiResult apiResult = new ApiResult(); // Getting the Service Specific Implementation contained in external DLL migrated from TUL IServiceImplementation serviceImplementation = _execution.GetServiceImplementation(org, service, edition); // Create and populate the RequestContext object and make it available for the service implementation so // service developer can implement logic based on information about the request and the user performing // the request RequestContext requestContext = RequestHelper.GetRequestContext(Request.Query, 0); requestContext.UserContext = _userHelper.GetUserContext(HttpContext); requestContext.Reportee = requestContext.UserContext.Reportee; // Get the serviceContext containing all metadata about current service ServiceContext serviceContext = _execution.GetServiceContext(org, service, edition); // Assign the Requestcontext and ViewBag to the serviceImplementation so // service developer can use the information in any of the service events that is called serviceImplementation.SetContext(requestContext, ViewBag, serviceContext, null, ModelState); // Set the platform services to the ServiceImplementation so the AltinnCore service can take // use of the plattform services PlatformServices platformServices = new PlatformServices(_authorization, _repository, _execution, org, service, edition); serviceImplementation.SetPlatformServices(platformServices); ViewBag.PlatformServices = platformServices; dynamic serviceModel = ParseApiBody(serviceImplementation.GetServiceModelType(), out apiResult, model); if (serviceModel == null) { // The parsing did not create any result Response.StatusCode = 403; return(new ObjectResult(apiResult)); } serviceImplementation.SetServiceModel(serviceModel); // ServiceEvent 2: HandleGetDataEvent // Runs the event where the service developer can implement functionality to retrieve data from internal/external sources // based on the data in the service model await serviceImplementation.RunServiceEvent(ServiceEventType.DataRetrieval); // RunService 3: Calcuation await serviceImplementation.RunServiceEvent(ServiceEventType.Calculation); // ServiceEvent 3: HandleCalculationEvent // Perform Calculation defined by the service developer // Only perform when the mode is to create a new instance or to specific calculate if (apiMode.Equals(ApiMode.Calculate) || apiMode.Equals(ApiMode.Create)) { if (apiMode.Equals(ApiMode.Calculate)) { // Returns a updated Service model with new calculated data. return(Ok(serviceModel)); } } // ServiceEvent 4: HandleValidationEvent // Perform additional Validation defined by the service developer. await serviceImplementation.RunServiceEvent(AltinnCore.ServiceLibrary.Enums.ServiceEventType.Validation); // Run the model Validation that handles validation defined on the model TryValidateModel(serviceModel); // If ApiMode is only validate the instance should not be created and only return any validation errors if (apiMode.Equals(ApiMode.Validate) || (!ModelState.IsValid && !apiMode.Equals(ApiMode.Create))) { MapModelStateToApiResult(ModelState, apiResult, serviceContext); if (apiResult.Status.Equals(ApiStatusType.ContainsError)) { if (apiMode.Equals(ApiMode.Validate)) { Response.StatusCode = 202; } else { Response.StatusCode = 400; } return(new ObjectResult(apiResult)); } return(Ok(apiResult)); } // Save Formdata to database this._form.SaveFormModel( serviceModel, instanceId, serviceImplementation.GetServiceModelType(), org, service, edition, requestContext.UserContext.ReporteeId); apiResult.InstanceId = instanceId; apiResult.Status = ApiStatusType.Ok; if (!requestContext.RequiresClientSideReleoad) { return(Ok(apiResult)); } { Response.StatusCode = 303; return(new ObjectResult(apiResult)); } }
public async Task <ActionResult> PutDataElement( [FromRoute] string org, [FromRoute] string app, [FromRoute] int instanceOwnerId, [FromRoute] Guid instanceGuid, [FromRoute] Guid dataGuid) { Instance instance = await instanceService.GetInstance(app, org, instanceOwnerId, instanceGuid); if (instance == null) { return(NotFound("Instance not found")); } DataElement dataElement = instance.Data.Find(m => m.Id == dataGuid.ToString()); if (dataElement == null) { return(NotFound("Data element not found")); } string elementType = dataElement.ElementType; IServiceImplementation serviceImplementation = await PrepareServiceImplementation(org, app, elementType); object serviceModel = ParseContentAndDeserializeServiceModel(serviceImplementation.GetServiceModelType(), out ActionResult contentError); if (contentError != null) { return(contentError); } if (serviceModel == null) { return(BadRequest("No data found in content")); } serviceImplementation.SetServiceModel(serviceModel); // send events to trigger application business logic await serviceImplementation.RunServiceEvent(ServiceEventType.DataRetrieval); await serviceImplementation.RunServiceEvent(ServiceEventType.Calculation); try { // Run the model Validation that handles validation defined on the model TryValidateModel(serviceModel); // send events to trigger application business logic await serviceImplementation.RunServiceEvent(AltinnCore.ServiceLibrary.Enums.ServiceEventType.Validation); } catch (Exception ex) { logger.LogError($"Validation errors are currently ignored: {ex.Message}"); } // Save Formdata to database this.dataService.UpdateData( serviceModel, instanceGuid, serviceImplementation.GetServiceModelType(), org, app, instanceOwnerId, dataGuid); // Create and store instance saved event await DispatchEvent(InstanceEventType.Saved.ToString(), instance, dataGuid); return(Ok(serviceModel)); }
public async Task <IActionResult> StartService(StartServiceModel startServiceModel) { // Dependency Injection: Getting the Service Specific Implementation based on the service parameter data store // Will compile code and load DLL in to memory for AltinnCore bool startService = true; IServiceImplementation serviceImplementation = _execution.GetServiceImplementation(startServiceModel.Org, startServiceModel.Service, startService); // Get the service context containing metadata about the service ServiceContext serviceContext = _execution.GetServiceContext(startServiceModel.Org, startServiceModel.Service, startService); // Create and populate the RequestContext object and make it available for the service implementation so // service developer can implement logic based on information about the request and the user performing // the request RequestContext requestContext = RequestHelper.GetRequestContext(Request.Query, 0); requestContext.UserContext = _userHelper.GetUserContext(HttpContext); // Populate the reportee information requestContext.UserContext.Reportee = _register.GetParty(startServiceModel.ReporteeID); requestContext.Reportee = requestContext.UserContext.Reportee; // Create platform service and assign to service implementation making it possible for the service implementation // to use plattform services. Also make it available in ViewBag so it can be used from Views PlatformServices platformServices = new PlatformServices(_authorization, _repository, _execution, startServiceModel.Org, startServiceModel.Service); serviceImplementation.SetPlatformServices(platformServices); ViewBag.PlatformServices = platformServices; // Assign the different context information to the service implementation making it possible for // the service developer to take use of this information serviceImplementation.SetContext(requestContext, ViewBag, serviceContext, null, ModelState); object serviceModel = null; if (!string.IsNullOrEmpty(startServiceModel.PrefillKey)) { _form.GetPrefill( startServiceModel.Org, startServiceModel.Service, serviceImplementation.GetServiceModelType(), startServiceModel.ReporteeID, startServiceModel.PrefillKey); } if (serviceModel == null) { // If the service model was not loaded from prefill. serviceModel = serviceImplementation.CreateNewServiceModel(); } // Assign service model to the implementation serviceImplementation.SetServiceModel(serviceModel); // Run Instansiation event await serviceImplementation.RunServiceEvent(ServiceEventType.Instantiation); // Run validate Instansiation event where await serviceImplementation.RunServiceEvent(ServiceEventType.ValidateInstantiation); // If ValidateInstansiation event has not added any errors the new form is saved and user is redirercted to the correct if (ModelState.IsValid) { if (serviceContext.WorkFlow.Any() && serviceContext.WorkFlow[0].StepType.Equals(StepType.Lookup)) { return(RedirectToAction("Lookup", new { org = startServiceModel.Org, service = startServiceModel.Service })); } // Create a new instance Id int formID = _execution.GetNewServiceInstanceID(startServiceModel.Org, startServiceModel.Service); _form.SaveFormModel( serviceModel, formID, serviceImplementation.GetServiceModelType(), startServiceModel.Org, startServiceModel.Service, requestContext.UserContext.ReporteeId); ServiceState currentState = _workflowSI.InitializeService(formID, startServiceModel.Org, startServiceModel.Service, requestContext.UserContext.ReporteeId); string redirectUrl = _workflowSI.GetUrlForCurrentState(formID, startServiceModel.Org, startServiceModel.Service, currentState.State); return(Redirect(redirectUrl)); } startServiceModel.ReporteeList = _authorization.GetReporteeList(requestContext.UserContext.UserId) .Select(x => new SelectListItem { Text = x.ReporteeNumber + " " + x.ReporteeName, Value = x.PartyID.ToString(), }).ToList(); HttpContext.Response.Cookies.Append("altinncorereportee", startServiceModel.ReporteeID.ToString()); return(View(startServiceModel)); }
public async Task <IActionResult> CompleteAndSendIn(string org, string service, int partyId, Guid instanceGuid, string view) { // Dependency Injection: Getting the Service Specific Implementation based on the service parameter data store // Will compile code and load DLL in to memory for AltinnCore IServiceImplementation serviceImplementation = _execution.GetServiceImplementation(org, service, false); // Get the serviceContext containing all metadata about current service ServiceContext serviceContext = _execution.GetServiceContext(org, service, false); // Create and populate the RequestContext object and make it available for the service implementation so // service developer can implement logic based on information about the request and the user performing // the request RequestContext requestContext = await PopulateRequestContext(instanceGuid); serviceImplementation.SetPlatformServices(_platformSI); // Assign data to the ViewBag so it is available to the service views or service implementation PopulateViewBag(org, service, instanceGuid, 0, requestContext, serviceContext, _platformSI); // Getting the Form Data Instance instance = await _instance.GetInstance(service, org, requestContext.UserContext.PartyId, instanceGuid); Guid.TryParse(instance.Data.Find(m => m.ElementType == FORM_ID).Id, out Guid dataId); object serviceModel = _data.GetFormData(instanceGuid, serviceImplementation.GetServiceModelType(), org, service, requestContext.UserContext.PartyId, dataId); serviceImplementation.SetServiceModel(serviceModel); ViewBag.FormID = instanceGuid; ViewBag.ServiceContext = serviceContext; serviceImplementation.SetContext(requestContext, serviceContext, null, ModelState); await serviceImplementation.RunServiceEvent(ServiceEventType.Validation); ApiResult apiResult = new ApiResult(); if (ModelState.IsValid) { ServiceState currentState = _workflowSI.MoveServiceForwardInWorkflow(instanceGuid, org, service, requestContext.UserContext.PartyId); if (currentState.State == WorkflowStep.Archived) { await _instance.ArchiveInstance(serviceModel, serviceImplementation.GetServiceModelType(), service, org, requestContext.UserContext.PartyId, instanceGuid); apiResult.NextState = currentState.State; } // Create and store the instance submitted event InstanceEvent instanceEvent = new InstanceEvent { AuthenticationLevel = requestContext.UserContext.AuthenticationLevel, EventType = InstanceEventType.Submited.ToString(), InstanceId = instance.Id, InstanceOwnerId = instance.InstanceOwnerId.ToString(), UserId = requestContext.UserContext.UserId, WorkflowStep = instance.Process.CurrentTask, }; await _event.SaveInstanceEvent(instanceEvent, org, service); } ModelHelper.MapModelStateToApiResult(ModelState, apiResult, serviceContext); if (apiResult.Status.Equals(ApiStatusType.ContainsError)) { Response.StatusCode = 202; } else { Response.StatusCode = 200; } return(new ObjectResult(apiResult)); }
public async Task <IActionResult> Index([FromBody] AltinnCoreApiModel model, string org, string service, Guid instanceId, ApiMode apiMode) { Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); ApiResult apiResult = new ApiResult(); // Getting the Service Specific Implementation contained in external DLL migrated from TUL IServiceImplementation serviceImplementation = _execution.GetServiceImplementation(org, service, false); // Create and populate the RequestContext object and make it available for the service implementation so // service developer can implement logic based on information about the request and the user performing // the request RequestContext requestContext = RequestHelper.GetRequestContext(Request.Query, Guid.Empty); requestContext.UserContext = await _userHelper.GetUserContext(HttpContext); requestContext.Party = requestContext.UserContext.Party; if (Request.Headers.Keys.Contains(VALIDATION_TRIGGER_FIELD)) { requestContext.ValidationTriggerField = Request.Headers[VALIDATION_TRIGGER_FIELD]; } // Get the serviceContext containing all metadata about current service ServiceContext serviceContext = _execution.GetServiceContext(org, service, false); // Assign the Requestcontext to the serviceImplementation so // service developer can use the information in any of the service events that is called serviceImplementation.SetContext(requestContext, serviceContext, null, ModelState); // Set the platform services to the ServiceImplementation so the AltinnCore service can take // use of the plattform services serviceImplementation.SetPlatformServices(_platformSI); ViewBag.PlatformServices = _platformSI; dynamic serviceModel = ParseApiBody(serviceImplementation.GetServiceModelType(), out apiResult, model); if (serviceModel == null) { // The parsing did not create any result Response.StatusCode = 403; return(new ObjectResult(apiResult)); } serviceImplementation.SetServiceModel(serviceModel); // ServiceEvent 2: HandleGetDataEvent // Runs the event where the service developer can implement functionality to retrieve data from internal/external sources // based on the data in the service model await serviceImplementation.RunServiceEvent(ServiceEventType.DataRetrieval); // RunService 3: Calcuation await serviceImplementation.RunServiceEvent(ServiceEventType.Calculation); // ServiceEvent 3: HandleCalculationEvent // Perform Calculation defined by the service developer // Only perform when the mode is to create a new instance or to specific calculate if (apiMode.Equals(ApiMode.Calculate) || apiMode.Equals(ApiMode.Create)) { if (apiMode.Equals(ApiMode.Calculate)) { // Returns a updated Service model with new calculated data. return(Ok(serviceModel)); } } // Run the model Validation that handles validation defined on the model TryValidateModel(serviceModel); // ServiceEvent 4: HandleValidationEvent // Perform additional Validation defined by the service developer. Runs when the ApiMode is set to Validate or Complete. if (apiMode.Equals(ApiMode.Validate) || apiMode.Equals(ApiMode.Complete)) { await serviceImplementation.RunServiceEvent(AltinnCore.ServiceLibrary.Enums.ServiceEventType.Validation); } // If ApiMode is only validate the instance should not be created and only return any validation errors if (apiMode.Equals(ApiMode.Validate) || (!ModelState.IsValid && !apiMode.Equals(ApiMode.Create))) { MapModelStateToApiResultForClient(ModelState, apiResult, serviceContext); if (apiResult.Status.Equals(ApiStatusType.ContainsError)) { if (apiMode.Equals(ApiMode.Validate)) { Response.StatusCode = 202; } else { Response.StatusCode = 400; } return(new ObjectResult(apiResult)); } return(Ok(apiResult)); } Instance instance = await _instance.GetInstance(service, org, requestContext.UserContext.PartyId, instanceId); Guid dataId = Guid.Parse(instance.Data.Find(m => m.ElementType.Equals(FORM_ID)).Id); // Save Formdata to database this._data.UpdateData( serviceModel, instanceId, serviceImplementation.GetServiceModelType(), org, service, requestContext.UserContext.PartyId, dataId); // Create and store instance saved event if (apiMode.Equals(ApiMode.Update)) { InstanceEvent instanceEvent = new InstanceEvent { AuthenticationLevel = requestContext.UserContext.AuthenticationLevel, EventType = InstanceEventType.Saved.ToString(), InstanceId = instance.Id, InstanceOwnerId = instance.InstanceOwnerId.ToString(), UserId = requestContext.UserContext.UserId, WorkflowStep = instance.Process.CurrentTask }; await _event.SaveInstanceEvent(instanceEvent, org, service); } if (apiMode.Equals(ApiMode.Complete)) { ServiceState currentState = _workflowSI.MoveServiceForwardInWorkflow(instanceId, org, service, requestContext.UserContext.PartyId); instance.Process = new Storage.Interface.Models.ProcessState() { CurrentTask = currentState.State.ToString(), IsComplete = false, }; Instance updatedInstance = await _instance.UpdateInstance(instance, service, org, requestContext.UserContext.PartyId, instanceId); Response.StatusCode = 200; apiResult.InstanceId = instanceId; apiResult.Instance = updatedInstance; apiResult.Status = ApiStatusType.Ok; apiResult.NextStepUrl = _workflowSI.GetUrlForCurrentState(instanceId, org, service, currentState.State); apiResult.NextState = currentState.State; return(new ObjectResult(apiResult)); } apiResult.InstanceId = instanceId; apiResult.Status = ApiStatusType.Ok; if (!requestContext.RequiresClientSideReleoad) { return(Ok(apiResult)); } { Response.StatusCode = 303; return(new ObjectResult(apiResult)); } }
public async Task <IActionResult> Gindex(string org, string service, int partyId, Guid instanceId) { // Getting the Service Specific Implementation contained in external DLL migrated from TUL IServiceImplementation serviceImplementation = _execution.GetServiceImplementation(org, service, false); // Create and populate the RequestContext object and make it available for the service implementation so // service developer can implement logic based on information about the request and the user performing // the request RequestContext requestContext = RequestHelper.GetRequestContext(Request.Query, instanceId); requestContext.UserContext = await _userHelper.GetUserContext(HttpContext); requestContext.Party = requestContext.UserContext.Party; // Get the serviceContext containing all metadata about current service ServiceContext serviceContext = _execution.GetServiceContext(org, service, false); // Assign data to the ViewBag so it is available to the service views or service implementation ViewBag.ServiceContext = serviceContext; ViewBag.RequestContext = requestContext; ViewBag.Org = org; ViewBag.Service = service; ViewBag.FormID = instanceId; // Assign the RequestContext to the serviceImplementation so // service developer can use the information in any of the service events that is called serviceImplementation.SetContext(requestContext, serviceContext, null, ModelState); // Set the platform services to the ServiceImplementation so the AltinnCore service can take // use of the plattform services serviceImplementation.SetPlatformServices(_platformSI); ViewBag.PlatformServices = _platformSI; Instance instance = await _instance.GetInstance(service, org, requestContext.UserContext.PartyId, instanceId); Guid dataId = Guid.Parse(instance.Data.Find(m => m.ElementType.Equals(FORM_ID)).Id); // Getting the Form Data from datastore object serviceModel = this._data.GetFormData( instanceId, serviceImplementation.GetServiceModelType(), org, service, requestContext.UserContext.PartyId, dataId); // Assing the populated service model to the service implementation serviceImplementation.SetServiceModel(serviceModel); // ServiceEvent 1: HandleGetDataEvent // Runs the event where the service developer can implement functionality to retrieve data from internal/external sources // based on the data in the service model await serviceImplementation.RunServiceEvent(AltinnCore.ServiceLibrary.Enums.ServiceEventType.DataRetrieval); // ServiceEvent 2: HandleCalculationEvent // Perform Calculation defined by the service developer await serviceImplementation.RunServiceEvent(AltinnCore.ServiceLibrary.Enums.ServiceEventType.Calculation); return(Ok(serviceModel)); }
public async Task <IActionResult> StartService(StartServiceModel startServiceModel) { // Dependency Injection: Getting the Service Specific Implementation based on the service parameter data store // Will compile code and load DLL in to memory for AltinnCore bool startService = true; IServiceImplementation serviceImplementation = _execution.GetServiceImplementation(startServiceModel.Org, startServiceModel.Service, startService); // Get the service context containing metadata about the service ServiceContext serviceContext = _execution.GetServiceContext(startServiceModel.Org, startServiceModel.Service, startService); // Create and populate the RequestContext object and make it available for the service implementation so // service developer can implement logic based on information about the request and the user performing // the request RequestContext requestContext = RequestHelper.GetRequestContext(Request.Query, Guid.Empty); requestContext.UserContext = await _userHelper.GetUserContext(HttpContext); // Populate the reportee information requestContext.UserContext.Party = await _register.GetParty(startServiceModel.PartyId); requestContext.Party = requestContext.UserContext.Party; // Create platform service and assign to service implementation making it possible for the service implementation // to use plattform services. Also make it available in ViewBag so it can be used from Views serviceImplementation.SetPlatformServices(_platformSI); // Assign the different context information to the service implementation making it possible for // the service developer to take use of this information serviceImplementation.SetContext(requestContext, serviceContext, null, ModelState); object serviceModel = null; if (!string.IsNullOrEmpty(startServiceModel.PrefillKey)) { _form.GetPrefill( startServiceModel.Org, startServiceModel.Service, serviceImplementation.GetServiceModelType(), startServiceModel.PartyId, startServiceModel.PrefillKey); } if (serviceModel == null) { // If the service model was not loaded from prefill. serviceModel = serviceImplementation.CreateNewServiceModel(); } // Assign service model to the implementation serviceImplementation.SetServiceModel(serviceModel); // Run Instansiation event await serviceImplementation.RunServiceEvent(ServiceEventType.Instantiation); // Run validate Instansiation event where await serviceImplementation.RunServiceEvent(ServiceEventType.ValidateInstantiation); // If ValidateInstansiation event has not added any errors the new form is saved and user is redirercted to the correct if (ModelState.IsValid) { if (serviceContext.WorkFlow.Any() && serviceContext.WorkFlow[0].StepType.Equals(StepType.Lookup)) { return(RedirectToAction("Lookup", new { org = startServiceModel.Org, service = startServiceModel.Service })); } int instanceOwnerId = requestContext.UserContext.PartyId; // Create a new instance document Instance instance = await _instance.InstantiateInstance(startServiceModel, serviceModel, serviceImplementation); // Create and store the instance created event InstanceEvent instanceEvent = new InstanceEvent { AuthenticationLevel = requestContext.UserContext.AuthenticationLevel, EventType = InstanceEventType.Created.ToString(), InstanceId = instance.Id, InstanceOwnerId = instanceOwnerId.ToString(), UserId = requestContext.UserContext.UserId, WorkflowStep = instance.Process.CurrentTask }; await _event.SaveInstanceEvent(instanceEvent, startServiceModel.Org, startServiceModel.Service); Enum.TryParse <WorkflowStep>(instance.Process.CurrentTask, out WorkflowStep currentStep); string redirectUrl = _workflowSI.GetUrlForCurrentState(Guid.Parse(instance.Id), startServiceModel.Org, startServiceModel.Service, currentStep); return(Redirect(redirectUrl)); } startServiceModel.PartyList = _authorization.GetPartyList(requestContext.UserContext.UserId) .Select(x => new SelectListItem { Text = (x.PartyTypeName == PartyType.Person) ? x.SSN + " " + x.Name : x.OrgNumber + " " + x.Name, Value = x.PartyId.ToString(), }).ToList(); HttpContext.Response.Cookies.Append(_generalSettings.GetAltinnPartyCookieName, startServiceModel.PartyId.ToString()); return(View(startServiceModel)); }
public async Task <IActionResult> Index([FromBody] AltinnCoreApiModel model, string org, string app, ApiMode apiMode) { Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); ApiResult apiResult = new ApiResult(); // Getting the Service Specific Implementation contained in external DLL migrated from TUL IServiceImplementation serviceImplementation = _execution.GetServiceImplementation(org, app, false); // Create and populate the RequestContext object and make it available for the service implementation so // service developer can implement logic based on information about the request and the user performing // the request RequestContext requestContext = RequestHelper.GetRequestContext(Request.Query, Guid.Empty); requestContext.UserContext = await _userHelper.GetUserContext(HttpContext); requestContext.Party = requestContext.UserContext.Party; // Get the serviceContext containing all metadata about current service ServiceContext serviceContext = _execution.GetServiceContext(org, app, false); // Assign the Requestcontext and ViewBag to the serviceImplementation so // service developer can use the information in any of the service events that is called serviceImplementation.SetContext(requestContext, serviceContext, null, ModelState); // Set the platform services to the ServiceImplementation so the AltinnCore service can take // use of the plattform services serviceImplementation.SetPlatformServices(_platformSI); dynamic serviceModel = ParseApiBody(serviceImplementation.GetServiceModelType(), out apiResult, model); if (serviceModel == null) { // The parsing did not create any result Response.StatusCode = 403; return(new ObjectResult(apiResult)); } serviceImplementation.SetServiceModel(serviceModel); // ServiceEvent 1: Validate Instansiation. In the service the service developer can add verification to be run at this point await serviceImplementation.RunServiceEvent(ServiceEventType.ValidateInstantiation); if (!ModelState.IsValid) { // The validatate instansiation failed MapModelStateToApiResult(ModelState, apiResult, serviceContext); apiResult.Status = ApiStatusType.Rejected; Response.StatusCode = 403; return(new ObjectResult(apiResult)); } // ServiceEvent 2: HandleGetDataEvent // Runs the event where the service developer can implement functionality to retrieve data from internal/external sources // based on the data in the service model await serviceImplementation.RunServiceEvent(ServiceEventType.DataRetrieval); // ServiceEvent 3: HandleCalculationEvent // Perform Calculation defined by the service developer // Only perform when the mode is to create a new instance or to specific calculate if (apiMode.Equals(ApiMode.Calculate) || apiMode.Equals(ApiMode.Create)) { await serviceImplementation.RunServiceEvent(ServiceEventType.Calculation); if (apiMode.Equals(ApiMode.Calculate)) { // Returns a updated Service model with new calculated data. return(Ok(serviceModel)); } } // Run the model Validation that handles validation defined on the model TryValidateModel(serviceModel); // ServiceEvent 4: HandleValidationEvent // Perform additional Validation defined by the service developer. Runs when the ApiMode is set to Validate or Complete. if (apiMode.Equals(ApiMode.Validate) || apiMode.Equals(ApiMode.Complete)) { await serviceImplementation.RunServiceEvent(AltinnCore.ServiceLibrary.Enums.ServiceEventType.Validation); } // If ApiMode is only validate the instance should not be created and only return any validation errors if (apiMode.Equals(ApiMode.Validate) || (!ModelState.IsValid && !apiMode.Equals(ApiMode.Create))) { MapModelStateToApiResult(ModelState, apiResult, serviceContext); if (apiResult.Status.Equals(ApiStatusType.ContainsError)) { if (apiMode.Equals(ApiMode.Validate)) { Response.StatusCode = 202; } else { Response.StatusCode = 400; } return(new ObjectResult(apiResult)); } return(Ok(apiResult)); } Guid instanceId = _execution.GetNewServiceInstanceID(); // Save Formdata to database Instance instance = this._data.InsertFormData( serviceModel, instanceId, serviceImplementation.GetServiceModelType(), org, app, requestContext.UserContext.PartyId); apiResult.InstanceId = instanceId; apiResult.Instance = instance; apiResult.Status = ApiStatusType.Ok; return(Ok(apiResult)); }