private async Task <ActionResult> CreateAppModelData(
string org,
string app,
Instance instance,
string dataType)
{
Guid instanceGuid = Guid.Parse(instance.Id.Split("/")[1]);
object appModel;
string classRef = _appResourcesService.GetClassRefForLogicDataType(dataType);
if (Request.ContentType == null)
{
appModel = _altinnApp.CreateNewAppModel(classRef);
}
else
{
ModelDeserializer deserializer = new ModelDeserializer(_logger, _altinnApp.GetAppModelType(classRef));
appModel = await deserializer.DeserializeAsync(Request.Body, Request.ContentType);
if (!string.IsNullOrEmpty(deserializer.Error))
{
return(BadRequest(deserializer.Error));
}
}
// runs prefill from repo configuration if config exists
await _prefillService.PrefillDataModel(instance.InstanceOwner.PartyId, dataType, appModel);
// send events to trigger application business logic
await _altinnApp.RunDataCreation(instance, appModel);
Dictionary <string, string> updatedValues =
DataHelper.GetUpdatedDataValues(
_appResourcesService.GetApplication().PresentationFields,
instance.PresentationTexts,
dataType,
appModel);
if (updatedValues.Count > 0)
{
await _instanceService.UpdatePresentationTexts(
int.Parse(instance.InstanceOwner.PartyId),
Guid.Parse(instance.Id.Split("/")[1]),
new PresentationTexts { Texts = updatedValues });
}
int instanceOwnerPartyId = int.Parse(instance.InstanceOwner.PartyId);
DataElement dataElement = await _dataService.InsertFormData(appModel, instanceGuid, _altinnApp.GetAppModelType(classRef), org, app, instanceOwnerPartyId, dataType);
SelfLinkHelper.SetDataAppSelfLinks(instanceOwnerPartyId, instanceGuid, dataElement, Request);
return(Created(dataElement.SelfLinks.Apps, dataElement));
}
public async Task <ActionResult> Put([FromQuery] string dataType)
{
string classRef = _appResourcesService.GetClassRefForLogicDataType(dataType);
if (string.IsNullOrEmpty(classRef))
{
return(BadRequest($"Invalid dataType {dataType} provided. Please provide a valid dataType as query parameter."));
}
ModelDeserializer deserializer = new ModelDeserializer(_logger, _altinnApp.GetAppModelType(classRef));
object appModel = await deserializer.DeserializeAsync(Request.Body, Request.ContentType);
if (!string.IsNullOrEmpty(deserializer.Error))
{
return(BadRequest(deserializer.Error));
}
if (appModel == null)
{
return(BadRequest("No data found in content"));
}
await _altinnApp.RunCalculation(appModel);
return(Ok(appModel));
}
private async Task StorePrefillParts(Instance instance, Application appInfo, List <RequestPart> parts)
{
Guid instanceGuid = Guid.Parse(instance.Id.Split("/")[1]);
int instanceOwnerIdAsInt = int.Parse(instance.InstanceOwner.PartyId);
string org = instance.Org;
string app = instance.AppId.Split("/")[1];
foreach (RequestPart part in parts)
{
DataType dataType = appInfo.DataTypes.Find(d => d.Id == part.Name);
DataElement dataElement;
if (dataType.AppLogic != null)
{
_logger.LogInformation($"Storing part {part.Name}");
Type type;
try
{
type = _altinnApp.GetAppModelType(dataType.AppLogic.ClassRef);
}
catch (Exception altinnAppException)
{
throw new ServiceException(HttpStatusCode.InternalServerError, $"App.GetAppModelType failed: {altinnAppException.Message}", altinnAppException);
}
ModelDeserializer deserializer = new ModelDeserializer(_logger, type);
object data = await deserializer.DeserializeAsync(part.Stream, part.ContentType);
if (!string.IsNullOrEmpty(deserializer.Error))
{
throw new InvalidOperationException(deserializer.Error);
}
await _prefillService.PrefillDataModel(instance.InstanceOwner.PartyId, part.Name, data);
await _altinnApp.RunDataCreation(instance, data);
dataElement = await _dataService.InsertFormData(
data,
instanceGuid,
type,
org,
app,
instanceOwnerIdAsInt,
part.Name);
}
else
{
dataElement = await _dataService.InsertBinaryData(instance.Id, part.Name, part.ContentType, part.FileName, part.Stream);
}
if (dataElement == null)
{
throw new ServiceException(HttpStatusCode.InternalServerError, $"Data service did not return a valid instance metadata when attempt to store data element {part.Name}");
}
}
}
public async Task <ActionResult> Post(
[FromRoute] string org,
[FromRoute] string app,
[FromQuery] string dataType)
{
if (string.IsNullOrEmpty(dataType))
{
return(BadRequest($"Invalid dataType {dataType} provided. Please provide a valid dataType as query parameter."));
}
string classRef = _appResourcesService.GetClassRefForLogicDataType(dataType);
if (string.IsNullOrEmpty(classRef))
{
return(BadRequest($"Invalid dataType {dataType} provided. Please provide a valid dataType as query parameter."));
}
if (GetPartyHeader(HttpContext).Count > 1)
{
return(BadRequest($"Invalid party. Only one allowed"));
}
InstanceOwner owner = await GetInstanceOwner(HttpContext);
if (string.IsNullOrEmpty(owner.PartyId))
{
return(StatusCode((int)HttpStatusCode.Forbidden));
}
EnforcementResult enforcementResult = await AuthorizeAction(org, app, Convert.ToInt32(owner.PartyId), "read");
if (!enforcementResult.Authorized)
{
return(Forbidden(enforcementResult));
}
ModelDeserializer deserializer = new ModelDeserializer(_logger, _altinnApp.GetAppModelType(classRef));
object appModel = await deserializer.DeserializeAsync(Request.Body, Request.ContentType);
if (!string.IsNullOrEmpty(deserializer.Error))
{
return(BadRequest(deserializer.Error));
}
// runs prefill from repo configuration if config exists
await _prefillService.PrefillDataModel(owner.PartyId, dataType, appModel);
Instance virutalInstance = new Instance()
{
InstanceOwner = owner
};
await _altinnApp.RunProcessDataRead(virutalInstance, null, appModel);
return(Ok(appModel));
}
private async Task StorePrefillParts(Instance instance, Application appInfo, List <RequestPart> parts)
{
Guid instanceGuid = Guid.Parse(instance.Id.Split("/")[1]);
int instanceOwnerIdAsInt = int.Parse(instance.InstanceOwner.PartyId);
DataElement dataElement = null;
string org = instance.Org;
string app = instance.AppId.Split("/")[1];
foreach (RequestPart part in parts)
{
DataType dataType = appInfo.DataTypes.Find(d => d.Id == part.Name);
if (dataType.AppLogic != null)
{
_logger.LogInformation($"Storing part {part.Name}");
Type type;
try
{
type = _altinnApp.GetAppModelType(dataType.AppLogic.ClassRef);
}
catch (Exception altinnAppException)
{
throw new ApplicationException($"App.GetAppModelType failed: {altinnAppException.Message}");
}
object data = DataController.ParseFormDataAndDeserialize(type, part.ContentType, part.Stream, out string errorText);
if (!string.IsNullOrEmpty(errorText))
{
throw new InvalidOperationException(errorText);
}
dataElement = await _dataService.InsertFormData(
data,
instanceGuid,
type,
org,
app,
instanceOwnerIdAsInt,
part.Name);
}
else
{
dataElement = await _dataService.InsertBinaryData(instance.Id, part.Name, part.ContentType, part.FileName, part.Stream);
}
if (dataElement == null)
{
throw new InvalidOperationException($"Dataservice did not return a valid instance metadata when attempt to store data element {part.Name}");
}
}
}
private async Task <ActionResult> CreateAppModelData(
string org,
string app,
Instance instance,
string dataType)
{
Guid instanceGuid = Guid.Parse(instance.Id.Split("/")[1]);
object appModel;
string classRef = _appResourcesService.GetClassRefForLogicDataType(dataType);
if (Request.ContentType == null)
{
appModel = _altinnApp.CreateNewAppModel(classRef);
}
else
{
appModel = ParseContentAndDeserializeServiceModel(_altinnApp.GetAppModelType(classRef), out ActionResult contentError);
if (contentError != null)
{
return(contentError);
}
}
// send events to trigger application business logic
await _altinnApp.RunAppEvent(AppEventType.AppModelCreation, appModel);
int instanceOwnerPartyId = int.Parse(instance.InstanceOwner.PartyId);
DataElement dataElement = await _dataService.InsertFormData(appModel, instanceGuid, _altinnApp.GetAppModelType(classRef), org, app, instanceOwnerPartyId, dataType);
SelfLinkHelper.SetDataAppSelfLinks(instanceOwnerPartyId, instanceGuid, dataElement, Request);
return(Created(dataElement.SelfLinks.Apps, dataElement));
}
public async Task <ActionResult <List <string> > > GetPageOrder(
[FromRoute] string org,
[FromRoute] string app,
[FromRoute] int instanceOwnerPartyId,
[FromRoute] Guid instanceGuid,
[FromQuery] string layoutSetId,
[FromQuery] string currentPage,
[FromQuery] string dataTypeId,
[FromBody] dynamic formData)
{
if (string.IsNullOrEmpty(dataTypeId))
{
return(BadRequest("Query parameter `dataTypeId` must be defined"));
}
string classRef = _resources.GetClassRefForLogicDataType(dataTypeId);
object data = JsonConvert.DeserializeObject(formData.ToString(), _altinnApp.GetAppModelType(classRef));
return(await _altinnApp.GetPageOrder(org, app, instanceOwnerPartyId, instanceGuid, layoutSetId, currentPage, dataTypeId, data));
}
public async Task <List <ValidationIssue> > ValidateDataElement(Instance instance, DataType dataType, DataElement dataElement)
{
_logger.LogInformation($"Validation of data element {dataElement.Id} of instance {instance.Id}");
// Todo. Figure out where to get this from
Dictionary <string, Dictionary <string, string> > serviceText = new Dictionary <string, Dictionary <string, string> >();
List <ValidationIssue> messages = new List <ValidationIssue>();
if (dataElement.ContentType == null)
{
ValidationIssue message = new ValidationIssue
{
InstanceId = instance.Id,
Code = ValidationIssueCodes.DataElementCodes.MissingContentType,
DataElementId = dataElement.Id,
Severity = ValidationIssueSeverity.Error,
Description = AppTextHelper.GetAppText(
ValidationIssueCodes.DataElementCodes.MissingContentType, serviceText, null, "nb")
};
messages.Add(message);
}
else
{
string contentTypeWithoutEncoding = dataElement.ContentType.Split(";")[0];
if (dataType.AllowedContentTypes != null && dataType.AllowedContentTypes.Count > 0 && dataType.AllowedContentTypes.All(ct => !ct.Equals(contentTypeWithoutEncoding, StringComparison.OrdinalIgnoreCase)))
{
ValidationIssue message = new ValidationIssue
{
InstanceId = instance.Id,
DataElementId = dataElement.Id,
Code = ValidationIssueCodes.DataElementCodes.ContentTypeNotAllowed,
Severity = ValidationIssueSeverity.Error,
Description = AppTextHelper.GetAppText(
ValidationIssueCodes.DataElementCodes.ContentTypeNotAllowed, serviceText, null, "nb"),
Field = dataType.Id
};
messages.Add(message);
}
}
if (dataType.MaxSize.HasValue && dataType.MaxSize > 0 && (long)dataType.MaxSize * 1024 * 1024 < dataElement.Size)
{
ValidationIssue message = new ValidationIssue
{
InstanceId = instance.Id,
DataElementId = dataElement.Id,
Code = ValidationIssueCodes.DataElementCodes.DataElementTooLarge,
Severity = ValidationIssueSeverity.Error,
Description = AppTextHelper.GetAppText(
ValidationIssueCodes.DataElementCodes.DataElementTooLarge, serviceText, null, "nb"),
Field = dataType.Id
};
messages.Add(message);
}
if (dataType.AppLogic != null)
{
Type modelType = _altinnApp.GetAppModelType(dataType.AppLogic.ClassRef);
Guid instanceGuid = Guid.Parse(instance.Id.Split("/")[1]);
string app = instance.AppId.Split("/")[1];
int instanceOwnerPartyId = int.Parse(instance.InstanceOwner.PartyId);
dynamic data = await _dataService.GetFormData(instanceGuid, modelType, instance.Org, app, instanceOwnerPartyId, Guid.Parse(dataElement.Id));
ModelStateDictionary validationResults = new ModelStateDictionary();
var actionContext = new ActionContext(
_httpContextAccessor.HttpContext,
new Microsoft.AspNetCore.Routing.RouteData(),
new ActionDescriptor(),
validationResults);
ValidationStateDictionary validationState = new ValidationStateDictionary();
_objectModelValidator.Validate(actionContext, validationState, null, data);
await _altinnApp.RunDataValidation(data, validationResults);
if (!validationResults.IsValid)
{
messages.AddRange(MapModelStateToIssueList(actionContext.ModelState, instance, dataElement.Id, serviceText));
}
}
return(messages);
}
public async Task <List <ValidationIssue> > ValidateDataElement(Instance instance, DataType dataType, DataElement dataElement)
{
_logger.LogInformation($"Validation of data element {dataElement.Id} of instance {instance.Id}");
// Todo. Figure out where to get this from
Dictionary <string, Dictionary <string, string> > serviceText = new Dictionary <string, Dictionary <string, string> >();
List <ValidationIssue> messages = new List <ValidationIssue>();
if (dataElement.ContentType == null)
{
ValidationIssue message = new ValidationIssue
{
InstanceId = instance.Id,
Code = ValidationIssueCodes.DataElementCodes.MissingContentType,
DataElementId = dataElement.Id,
Severity = ValidationIssueSeverity.Error,
Description = ServiceTextHelper.GetServiceText(
ValidationIssueCodes.DataElementCodes.MissingContentType, serviceText, null, "nb")
};
messages.Add(message);
}
else
{
string contentTypeWithoutEncoding = dataElement.ContentType.Split(";")[0];
if (dataType.AllowedContentTypes.All(ct => !ct.Equals(contentTypeWithoutEncoding, StringComparison.OrdinalIgnoreCase)))
{
ValidationIssue message = new ValidationIssue
{
InstanceId = instance.Id,
DataElementId = dataElement.Id,
Code = ValidationIssueCodes.DataElementCodes.ContentTypeNotAllowed,
Severity = ValidationIssueSeverity.Error,
Description = ServiceTextHelper.GetServiceText(
ValidationIssueCodes.DataElementCodes.ContentTypeNotAllowed, serviceText, null, "nb")
};
messages.Add(message);
}
}
if (dataType.MaxSize.HasValue && dataType.MaxSize > 0 && (long)dataType.MaxSize * 1024 * 1024 < dataElement.Size)
{
ValidationIssue message = new ValidationIssue
{
InstanceId = instance.Id,
DataElementId = dataElement.Id,
Code = ValidationIssueCodes.DataElementCodes.DataElementTooLarge,
Severity = ValidationIssueSeverity.Error,
Description = ServiceTextHelper.GetServiceText(
ValidationIssueCodes.DataElementCodes.DataElementTooLarge, serviceText, null, "nb")
};
messages.Add(message);
}
if (dataType.AppLogic != null)
{
Type modelType = _altinnApp.GetAppModelType(dataType.AppLogic.ClassRef);
Guid instanceGuid = Guid.Parse(instance.Id.Split("/")[1]);
string app = instance.AppId.Split("/")[1];
int instanceOwnerPartyId = int.Parse(instance.InstanceOwner.PartyId);
dynamic data = _dataService.GetFormData(instanceGuid, modelType, instance.Org, app, instanceOwnerPartyId, Guid.Parse(dataElement.Id));
var context = new ValidationContext(data);
List <System.ComponentModel.DataAnnotations.ValidationResult> validationResults = new List <System.ComponentModel.DataAnnotations.ValidationResult>();
bool isValid = await _altinnApp.RunValidation(data.Result, modelType, validationResults);
isValid = Validator.TryValidateObject(data, context, validationResults, true) && isValid;
if (!isValid)
{
messages.AddRange(MapModelStateToIssueList(instance, validationResults, dataElement.Id, dataElement.DataType, serviceText));
}
}
return(messages);
}
