/// <inheritdoc />
public async Task <TextResource> GetText(string org, string app, string language)
{
TextResource textResource = null;
string cacheKey = $"{org}-{app}-{language.ToLower()}";
if (!_memoryCache.TryGetValue(cacheKey, out textResource))
{
// Key not in cache, so get text from Platform Storage
string url = $"applications/{org}/{app}/texts/{language}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _settings.RuntimeCookieName);
HttpResponseMessage response = await _client.GetAsync(token, url);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
textResource = await response.Content.ReadAsAsync <TextResource>();
_memoryCache.Set(cacheKey, textResource, cacheEntryOptions);
}
else
{
_logger.LogError($"Getting text resource for {org}/{app} with language code: {language} failed with statuscode {response.StatusCode}");
}
}
return(textResource);
}
public async Task <DataElement> InsertFormData <T>(Instance instance, string dataType, T dataToSerialize, Type type)
{
string apiUrl = $"instances/{instance.Id}/data?dataType={dataType ?? FORM_ID}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _cookieOptions.Cookie.Name);
JwtTokenUtil.AddTokenToRequestHeader(_client, token);
DataElement dataElement;
XmlSerializer serializer = new XmlSerializer(type);
using MemoryStream stream = new MemoryStream();
serializer.Serialize(stream, dataToSerialize);
stream.Position = 0;
StreamContent streamContent = new StreamContent(stream);
streamContent.Headers.ContentType = MediaTypeHeaderValue.Parse("application/xml");
Task <HttpResponseMessage> response = _client.PostAsync(apiUrl, streamContent);
if (!response.Result.IsSuccessStatusCode)
{
_logger.Log(LogLevel.Error, "unable to save form data for instance{0} due to response {1}", instance.Id, response.Result.StatusCode);
return(null);
}
string instanceData = await response.Result.Content.ReadAsStringAsync();
dataElement = JsonConvert.DeserializeObject <DataElement>(instanceData);
return(dataElement);
}
public async Task <DataElement> InsertBinaryData(string instanceId, string dataType, string contentType, string fileName, Stream stream)
{
string apiUrl = $"{_platformSettings.ApiStorageEndpoint}instances/{instanceId}/data?dataType={dataType}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _settings.RuntimeCookieName);
DataElement dataElement;
StreamContent content = new StreamContent(stream);
content.Headers.ContentType = MediaTypeHeaderValue.Parse(contentType);
if (!string.IsNullOrEmpty(fileName))
{
string contentHeaderString = $"attachment; filename={fileName}";
content.Headers.ContentDisposition = ContentDispositionHeaderValue.Parse(contentHeaderString);
}
HttpResponseMessage response = await _client.PostAsync(token, apiUrl, content);
if (response.IsSuccessStatusCode)
{
string instancedata = await response.Content.ReadAsStringAsync();
dataElement = JsonConvert.DeserializeObject <DataElement>(instancedata);
return(dataElement);
}
_logger.LogError($"Storing attachment for instance {instanceId} failed with status code {response.StatusCode} - content {await response.Content.ReadAsStringAsync()}");
throw await PlatformHttpException.CreateAsync(response);
}
/// <inheritdoc />
public async Task <object> GetFormData(Guid instanceGuid, Type type, string org, string app, int instanceOwnerId, Guid dataId)
{
string instanceIdentifier = $"{instanceOwnerId}/{instanceGuid}";
string apiUrl = $"instances/{instanceIdentifier}/data/{dataId}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _settings.RuntimeCookieName);
HttpResponseMessage response = await _client.GetAsync(token, apiUrl);
if (response.IsSuccessStatusCode)
{
XmlSerializer serializer = new XmlSerializer(type);
try
{
using Stream stream = await response.Content.ReadAsStreamAsync();
return(serializer.Deserialize(stream));
}
catch (Exception ex)
{
_logger.LogError($"Cannot deserialize XML form data read from storage: {ex}");
throw new ServiceException(HttpStatusCode.Conflict, $"Cannot deserialize XML form data from storage", ex);
}
}
throw await PlatformHttpException.CreateAsync(response);
}
/// <inheritdoc/>
public async Task <int> PartyLookup(string orgNo, string person)
{
string endpointUrl = "parties/lookup";
PartyLookup partyLookup = new PartyLookup()
{
Ssn = person, OrgNo = orgNo
};
string bearerToken = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _generalSettings.JwtCookieName);
string accessToken = _accessTokenGenerator.GenerateAccessToken("platform", "events");
StringContent content = new StringContent(JsonSerializer.Serialize(partyLookup));
content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json");
HttpResponseMessage response = await _client.PostAsync(bearerToken, endpointUrl, content, accessToken);
if (response.StatusCode == HttpStatusCode.OK)
{
Party party = await response.Content.ReadAsAsync <Party>();
return(party.PartyId);
}
else
{
string reason = await response.Content.ReadAsStringAsync();
_logger.LogError($"// RegisterService // PartyLookup // Failed to lookup party in platform register. Response {response}. \n Reason {reason}.");
throw await PlatformHttpException.CreateAsync(response);
}
}
/// <inheritdoc />
/// TODO - fix logic, what are you using this for? It will only get instances for a instance owners the way storage is implemented now
public async Task <List <Instance> > GetInstances(string app, string org, int instanceOwnerId)
{
List <Instance> instances = null;
DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Instance));
string appId = ApplicationHelper.GetFormattedApplicationId(org, app);
string apiUrl = $"instances?instanceOwnerId={instanceOwnerId}&appId={appId}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _cookieOptions.Cookie.Name);
JwtTokenUtil.AddTokenToRequestHeader(_client, token);
HttpResponseMessage response = await _client.GetAsync(apiUrl);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
string instanceData = await response.Content.ReadAsStringAsync();
instances = JsonConvert.DeserializeObject <List <Instance> >(instanceData);
}
else if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
{
return(instances);
}
else
{
_logger.LogError("Unable to fetch instances");
throw new PlatformClientException(response);
}
return(instances);
}
/// <inheritdoc />
public async Task <Instance> UpdateInstance(object dataToSerialize, string app, string org, int instanceOwnerId, Guid instanceId)
{
string instanceIdentifier = $"{instanceOwnerId}/{instanceId}";
Instance instance = new Instance();
string apiUrl = $"instances/{instanceIdentifier}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _cookieOptions.Cookie.Name);
JwtTokenUtil.AddTokenToRequestHeader(_client, token);
string jsonData = JsonConvert.SerializeObject(dataToSerialize);
StringContent httpContent = new StringContent(jsonData, Encoding.UTF8, "application/json");
HttpResponseMessage response = await _client.PutAsync(apiUrl, httpContent);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
string instanceData = await response.Content.ReadAsStringAsync();
instance = JsonConvert.DeserializeObject <Instance>(instanceData);
}
else
{
_logger.LogError($"Unable to update instance with instance id {instanceId}");
throw new PlatformClientException(response);
}
return(instance);
}
/// <inheritdoc />
/// Get instances of an instance owner.
public async Task <List <Instance> > GetInstances(int instanceOwnerPartyId)
{
string apiUrl = $"instances/{instanceOwnerPartyId}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _settings.RuntimeCookieName);
JwtTokenUtil.AddTokenToRequestHeader(_client, token);
HttpResponseMessage response = await _client.GetAsync(apiUrl);
if (response.StatusCode == HttpStatusCode.OK)
{
string instanceData = await response.Content.ReadAsStringAsync();
List <Instance> instances = JsonConvert.DeserializeObject <List <Instance> >(instanceData);
return(instances);
}
else if (response.StatusCode == HttpStatusCode.NotFound)
{
return(null);
}
else
{
_logger.LogError("Unable to fetch instances");
throw new PlatformHttpException(response);
}
}
/// <inheritdoc />
public async Task <Instance> GetInstance(string app, string org, int instanceOwnerId, Guid instanceId)
{
string instanceIdentifier = $"{instanceOwnerId}/{instanceId}";
Instance instance = new Instance();
DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Instance));
string apiUrl = $"instances/{instanceIdentifier}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _cookieOptions.Cookie.Name);
JwtTokenUtil.AddTokenToRequestHeader(_client, token);
HttpResponseMessage response = await _client.GetAsync(apiUrl);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
string instanceData = await response.Content.ReadAsStringAsync();
instance = JsonConvert.DeserializeObject <Instance>(instanceData);
}
else
{
_logger.LogError($"Unable to fetch instance with instance id {instanceId}");
throw new PlatformClientException(response);
}
return(instance);
}
/// <inheritdoc />
public async Task <List <AttachmentList> > GetBinaryDataList(string org, string app, int instanceOwnerId, Guid instanceGuid)
{
string instanceIdentifier = $"{instanceOwnerId}/{instanceGuid}";
string apiUrl = $"instances/{instanceIdentifier}/dataelements";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _settings.RuntimeCookieName);
DataElementList dataList;
List <AttachmentList> attachmentList = new List <AttachmentList>();
HttpResponseMessage response = await _client.GetAsync(token, apiUrl);
if (response.StatusCode == HttpStatusCode.OK)
{
string instanceData = await response.Content.ReadAsStringAsync();
dataList = JsonConvert.DeserializeObject <DataElementList>(instanceData);
ExtractAttachments(dataList.DataElements, attachmentList);
return(attachmentList);
}
_logger.Log(LogLevel.Error, "Unable to fetch attachment list {0}", response.StatusCode);
throw await PlatformHttpException.CreateAsync(response);
}
/// <inheritdoc/>
public async Task <string> SaveInstanceEvent(object dataToSerialize, string org, string appName)
{
InstanceEvent instanceEvent = (InstanceEvent)dataToSerialize;
instanceEvent.CreatedDateTime = DateTime.UtcNow;
string apiUrl = $"instances/{instanceEvent.InstanceId}/events";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _cookieOptions.Cookie.Name);
JwtTokenUtil.AddTokenToRequestHeader(_client, token);
try
{
HttpResponseMessage response = await _client.PostAsync(apiUrl, new StringContent(instanceEvent.ToString(), Encoding.UTF8, "application/json"));
string eventData = await response.Content.ReadAsStringAsync();
InstanceEvent result = JsonConvert.DeserializeObject <InstanceEvent>(eventData);
return(result.Id.ToString());
}
catch
{
_logger.LogError($"Unable to store instance event");
return(null);
}
}
/// <inheritdoc />
public async Task <DataElement> UpdateData <T>(T dataToSerialize, Guid instanceGuid, Type type, string org, string app, int instanceOwnerId, Guid dataId)
{
string instanceIdentifier = $"{instanceOwnerId}/{instanceGuid}";
string apiUrl = $"instances/{instanceIdentifier}/data/{dataId}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _settings.RuntimeCookieName);
XmlSerializer serializer = new XmlSerializer(type);
using MemoryStream stream = new MemoryStream();
serializer.Serialize(stream, dataToSerialize);
stream.Position = 0;
StreamContent streamContent = new StreamContent(stream);
streamContent.Headers.ContentType = MediaTypeHeaderValue.Parse("application/xml");
HttpResponseMessage response = await _client.PutAsync(token, apiUrl, streamContent);
if (response.IsSuccessStatusCode)
{
string instanceData = await response.Content.ReadAsStringAsync();
DataElement dataElement = JsonConvert.DeserializeObject <DataElement>(instanceData);
return(dataElement);
}
throw await PlatformHttpException.CreateAsync(response);
}
/// <inheritdoc/>
public async Task <List <InstanceEvent> > GetInstanceEvents(string instanceId, string instanceOwnerId, string org, string app, string[] eventTypes, string from, string to)
{
string apiUrl = $"{instanceOwnerId}/{instanceId}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _settings.RuntimeCookieName);
if (eventTypes != null)
{
StringBuilder bld = new StringBuilder();
foreach (string type in eventTypes)
{
bld.Append($"&eventTypes={type}");
}
apiUrl += bld.ToString();
}
if (!(string.IsNullOrEmpty(from) || string.IsNullOrEmpty(to)))
{
apiUrl += $"&from={from}&to={to}";
}
HttpResponseMessage response = await _client.GetAsync(token, apiUrl);
if (response.IsSuccessStatusCode)
{
string eventData = await response.Content.ReadAsStringAsync();
List <InstanceEvent> instanceEvents = JsonConvert.DeserializeObject <List <InstanceEvent> >(eventData);
return(instanceEvents);
}
throw await PlatformHttpException.CreateAsync(response);
}
/// <inheritdoc />
public async Task <Instance> UpdateData <T>(T dataToSerialize, Guid instanceGuid, Type type, string org, string app, int instanceOwnerId, Guid dataId)
{
string instanceIdentifier = $"{instanceOwnerId}/{instanceGuid}";
string apiUrl = $"instances/{instanceIdentifier}/data/{dataId}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _cookieOptions.Cookie.Name);
JwtTokenUtil.AddTokenToRequestHeader(_client, token);
XmlSerializer serializer = new XmlSerializer(type);
using (MemoryStream stream = new MemoryStream())
{
serializer.Serialize(stream, dataToSerialize);
stream.Position = 0;
StreamContent streamContent = new StreamContent(stream);
streamContent.Headers.ContentType = MediaTypeHeaderValue.Parse("application/xml");
Task <HttpResponseMessage> response = _client.PutAsync(apiUrl, streamContent);
if (!response.Result.IsSuccessStatusCode)
{
_logger.LogError($"Unable to save form model for instance {instanceGuid}");
}
string instanceData = await response.Result.Content.ReadAsStringAsync();
Instance instance = JsonConvert.DeserializeObject <Instance>(instanceData);
return(instance);
}
}
/// <inheritdoc/>
public ServiceState GetCurrentState(Guid instanceId, string org, string appName, int instanceOwnerId)
{
string instanceIdentifier = $"{instanceOwnerId}/{instanceId}";
Instance instance;
DataContractJsonSerializer serializer = new DataContractJsonSerializer(typeof(Instance));
string apiUrl = $"instances/{instanceIdentifier}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _cookieOptions.Cookie.Name);
JwtTokenUtil.AddTokenToRequestHeader(_client, token);
Task<HttpResponseMessage> response = _client.GetAsync(apiUrl);
if (response.Result.StatusCode == System.Net.HttpStatusCode.OK)
{
string instanceData = response.Result.Content.ReadAsStringAsync().Result;
instance = JsonConvert.DeserializeObject<Instance>(instanceData);
}
else
{
throw new Exception("Unable to fetch workflow state");
}
Enum.TryParse<WorkflowStep>(instance.Process.CurrentTask, out WorkflowStep currentWorkflowState);
return new ServiceState
{
State = currentWorkflowState
};
}
/// <inheritdoc />
public async Task <List <AttachmentList> > GetBinaryDataList(string org, string app, int instanceOwnerId, Guid instanceGuid)
{
string instanceIdentifier = $"{instanceOwnerId}/{instanceGuid}";
string apiUrl = $"instances/{instanceIdentifier}/data";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _cookieOptions.Cookie.Name);
JwtTokenUtil.AddTokenToRequestHeader(_client, token);
List <DataElement> dataList = null;
List <AttachmentList> attachmentList = new List <AttachmentList>();
HttpResponseMessage response = await _client.GetAsync(apiUrl);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
string instanceData = await response.Content.ReadAsStringAsync();
dataList = JsonConvert.DeserializeObject <List <DataElement> >(instanceData);
ExtractAttachments(dataList, attachmentList);
}
else
{
_logger.Log(LogLevel.Error, "Unable to fetch attachment list {0}", response.StatusCode);
}
return(attachmentList);
}
/// <inheritdoc />
public object GetFormData(Guid instanceGuid, Type type, string org, string app, int instanceOwnerId, Guid dataId)
{
string instanceIdentifier = $"{instanceOwnerId}/{instanceGuid}";
string apiUrl = $"instances/{instanceIdentifier}/data/{dataId}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _cookieOptions.Cookie.Name);
JwtTokenUtil.AddTokenToRequestHeader(_client, token);
Task <HttpResponseMessage> response = _client.GetAsync(apiUrl);
if (response.Result.IsSuccessStatusCode)
{
XmlSerializer serializer = new XmlSerializer(type);
try
{
using (Stream stream = response.Result.Content.ReadAsStreamAsync().Result)
{
return(serializer.Deserialize(stream));
}
}
catch
{
return(Activator.CreateInstance(type));
}
}
else
{
return(Activator.CreateInstance(type));
}
}
public async Task <DataElement> InsertFormData <T>(Instance instance, string dataType, T dataToSerialize, Type type)
{
string apiUrl = $"instances/{instance.Id}/data?dataType={dataType}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _settings.RuntimeCookieName);
DataElement dataElement;
XmlSerializer serializer = new XmlSerializer(type);
using MemoryStream stream = new MemoryStream();
serializer.Serialize(stream, dataToSerialize);
stream.Position = 0;
StreamContent streamContent = new StreamContent(stream);
streamContent.Headers.ContentType = MediaTypeHeaderValue.Parse("application/xml");
HttpResponseMessage response = await _client.PostAsync(token, apiUrl, streamContent);
if (response.IsSuccessStatusCode)
{
string instanceData = await response.Content.ReadAsStringAsync();
dataElement = JsonConvert.DeserializeObject <DataElement>(instanceData);
return(dataElement);
}
_logger.Log(LogLevel.Error, "unable to save form data for instance{0} due to response {1}", instance.Id, response.StatusCode);
throw await PlatformHttpException.CreateAsync(response);
}
/// <inheritdoc />
public async Task <Instance> UpdateProcess(Instance instance)
{
ProcessState processState = instance.Process;
string apiUrl = $"instances/{instance.Id}/process";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _settings.RuntimeCookieName);
JwtTokenUtil.AddTokenToRequestHeader(_client, token);
string processStateString = JsonConvert.SerializeObject(processState);
_logger.LogInformation($"update process state: {processStateString}");
StringContent httpContent = new StringContent(processStateString, Encoding.UTF8, "application/json");
HttpResponseMessage response = await _client.PutAsync(apiUrl, httpContent);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
string instanceData = await response.Content.ReadAsStringAsync();
Instance updatedInstance = JsonConvert.DeserializeObject <Instance>(instanceData);
return(updatedInstance);
}
else
{
_logger.LogError($"Unable to update instance process with instance id {instance.Id}");
throw new PlatformHttpException(response);
}
}
/// <inheritdoc />
public async Task <DataElement> UpdateBinaryData(string org, string app, int instanceOwnerId, Guid instanceGuid, Guid dataGuid, HttpRequest request)
{
string instanceIdentifier = $"{instanceOwnerId}/{instanceGuid}";
string apiUrl = $"{_platformSettings.ApiStorageEndpoint}instances/{instanceIdentifier}/data/{dataGuid}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _settings.RuntimeCookieName);
StreamContent content = CreateContentStream(request);
JwtTokenUtil.AddTokenToRequestHeader(_client, token);
HttpResponseMessage response = await _client.PutAsync(apiUrl, content);
if (response.IsSuccessStatusCode)
{
string instancedata = await response.Content.ReadAsStringAsync();
DataElement dataElement = JsonConvert.DeserializeObject <DataElement>(instancedata);
return(dataElement);
}
_logger.LogError($"Updating attachment {dataGuid} for instance {instanceGuid} failed with status code {response.StatusCode}");
throw new PlatformHttpException(response);
}
/// <inheritdoc />
public async Task <Guid> SaveFormAttachment(string org, string appName, int instanceOwnerId, Guid instanceGuid, string attachmentType, string attachmentName, HttpRequest attachment)
{
string instanceIdentifier = $"{instanceOwnerId}/{instanceGuid}";
string apiUrl = $"{_platformSettings.GetApiStorageEndpoint}instances/{instanceIdentifier}/data?elementType={attachmentType}&attachmentName={attachmentName}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _cookieOptions.Cookie.Name);
Instance instance;
FileExtensionContentTypeProvider provider = new FileExtensionContentTypeProvider();
string contentType;
provider.TryGetContentType(attachmentName, out contentType);
// using a non-generic client in order to support unknown content type
using (HttpClient client = new HttpClient())
{
client.BaseAddress = new Uri(apiUrl);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(contentType));
JwtTokenUtil.AddTokenToRequestHeader(client, token);
if (attachment.ContentType.StartsWith("multipart"))
{
StreamContent content = new StreamContent(attachment.Body);
content.Headers.ContentType = MediaTypeHeaderValue.Parse(attachment.ContentType);
HttpResponseMessage response = client.PostAsync(apiUrl, content).Result;
response.EnsureSuccessStatusCode();
string instancedata = await response.Content.ReadAsStringAsync();
instance = JsonConvert.DeserializeObject <Instance>(instancedata);
return(Guid.Parse(instance.Data.Find(m => m.FileName.Equals(attachmentName)).Id));
}
else
{
using (Stream input = attachment.Body)
{
HttpContent fileStreamContent = new StreamContent(input);
using (MultipartFormDataContent formData = new MultipartFormDataContent())
{
fileStreamContent.Headers.ContentType = MediaTypeHeaderValue.Parse(contentType);
formData.Add(fileStreamContent, attachmentType, attachmentName);
HttpResponseMessage response = client.PostAsync(apiUrl, formData).Result;
response.EnsureSuccessStatusCode();
string instancedata = await response.Content.ReadAsStringAsync();
instance = JsonConvert.DeserializeObject <Instance>(instancedata);
return(Guid.Parse(instance.Data.Find(m => m.FileName.Equals(attachmentName)).Id));
}
}
}
}
}
/// <inheritdoc />
public void DeleteFormAttachment(string org, string appName, int instanceOwnerId, Guid instanceGuid, string attachmentType, string attachmentId)
{
string instanceIdentifier = $"{instanceOwnerId}/{instanceGuid}";
List <AttachmentList> attachmentList = new List <AttachmentList>();
string apiUrl = $"instances/{instanceIdentifier}/data/{attachmentId}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _cookieOptions.Cookie.Name);
JwtTokenUtil.AddTokenToRequestHeader(_client, token);
Task <HttpResponseMessage> response = _client.DeleteAsync(apiUrl);
response.Result.EnsureSuccessStatusCode();
}
/// <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);
}
/// <inheritdoc/>
public async Task <bool> DeleteAllInstanceEvents(string instanceId, string instanceOwnerId, string org, string app)
{
string instanceIdentifier = $"{instanceOwnerId}/{instanceId}";
string apiUrl = $"instances/{instanceIdentifier}/events";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _settings.RuntimeCookieName);
HttpResponseMessage response = await _client.DeleteAsync(token, apiUrl);
if (response.IsSuccessStatusCode)
{
return(true);
}
throw await PlatformHttpException.CreateAsync(response);
}
/// <inheritdoc />
public async Task <bool> DeleteBinaryData(string org, string app, int instanceOwnerId, Guid instanceGuid, Guid dataGuid)
{
string instanceIdentifier = $"{instanceOwnerId}/{instanceGuid}";
string apiUrl = $"instances/{instanceIdentifier}/data/{dataGuid}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _settings.RuntimeCookieName);
HttpResponseMessage response = await _client.DeleteAsync(token, apiUrl);
if (response.IsSuccessStatusCode)
{
return(true);
}
_logger.LogError($"Deleting form attachment {dataGuid} for instance {instanceGuid} failed with status code {response.StatusCode}");
throw await PlatformHttpException.CreateAsync(response);
}
/// <inheritdoc/>
public async Task <Party> GetParty(int partyId)
{
string token = JwtTokenUtil.GetTokenFromContext(_contextaccessor.HttpContext, "AltinnStudioRuntime");
string url = $"parties/{partyId}";
HttpResponseMessage response = await _client.GetAsync(token, url);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
Party party = await response.Content.ReadAsAsync <Party>();
return(party);
}
throw new PlatformHttpException(response);
}
/// <inheritdoc/>
public async Task <UserProfile> GetUser(int userId)
{
string token = JwtTokenUtil.GetTokenFromContext(_contextaccessor.HttpContext, "AltinnStudioRuntime");
string url = $"users/{userId}";
HttpResponseMessage response = await _client.GetAsync(token, url);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
UserProfile profile = await response.Content.ReadAsAsync <UserProfile>();
return(profile);
}
throw new PlatformHttpException(response);
}
/// <inheritdoc />
public Task <Stream> GetBinaryData(string org, string app, int instanceOwnerId, Guid instanceGuid, Guid dataId)
{
string instanceIdentifier = $"{instanceOwnerId}/{instanceGuid}";
string apiUrl = $"instances/{instanceIdentifier}/data/{dataId}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _cookieOptions.Cookie.Name);
JwtTokenUtil.AddTokenToRequestHeader(_client, token);
HttpResponseMessage response = _client.GetAsync(apiUrl).Result;
if (response.IsSuccessStatusCode)
{
return(response.Content.ReadAsStreamAsync());
}
return(null);
}
/// <inheritdoc />
public async Task <string> RefreshToken()
{
string endpointUrl = $"refresh";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, Constants.General.RuntimeCookieName);
HttpResponseMessage response = await _client.GetAsync(token, endpointUrl);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
string refreshedToken = await response.Content.ReadAsStringAsync();
refreshedToken = refreshedToken.Replace('"', ' ').Trim();
return(refreshedToken);
}
_logger.LogError($"Refreshing JwtToken failed with status code {response.StatusCode}");
return(string.Empty);
}
/// <inheritdoc />
public async Task <DataElement> Update(Instance instance, DataElement dataElement)
{
string apiUrl = $"{_platformSettings.ApiStorageEndpoint}instances/{instance.Id}/dataelements/{dataElement.Id}";
string token = JwtTokenUtil.GetTokenFromContext(_httpContextAccessor.HttpContext, _settings.RuntimeCookieName);
StringContent jsonString = new StringContent(JsonConvert.SerializeObject(dataElement), Encoding.UTF8, "application/json");
HttpResponseMessage response = await _client.PutAsync(token, apiUrl, jsonString);
if (response.IsSuccessStatusCode)
{
DataElement result = JsonConvert.DeserializeObject <DataElement>(await response.Content.ReadAsStringAsync());
return(result);
}
throw await PlatformHttpException.CreateAsync(response);
}
