public static IReadOnlyList <ValidationIssue> GetValidationIssues(this PackageValidationSet validationSet)
{
IReadOnlyList <ValidationIssue> issues = null;
if (validationSet != null)
{
// Get the failed validation set's validation issues. The issues are ordered by their
// key so that it appears that issues are appended as more validations fail.
issues = validationSet
.PackageValidations
.SelectMany(v => v.PackageValidationIssues)
.OrderBy(i => i.Key)
.Select(i => ValidationIssue.Deserialize(i.IssueCode, i.Data))
.ToList();
// Filter out unknown issues and deduplicate the issues by code and data. This also deduplicates cases
// where there is extraneous data in the serialized data field or if the issue code is unknown.
issues = issues
.GroupBy(x => new { x.IssueCode, Data = x.Serialize() })
.Select(x => x.First())
.ToList();
}
// If the package failed validation but we could not find an issue that explains why, use a generic error message.
if (issues == null || !issues.Any())
{
issues = new[] { ValidationIssue.Unknown };
}
return(issues);
}
public async Task <IActionResult> ValidateData(
[FromRoute] string org,
[FromRoute] string app,
[FromRoute] int instanceOwnerId,
[FromRoute] Guid instanceId,
[FromRoute] Guid dataGuid)
{
Instance instance = await _instanceService.GetInstance(app, org, instanceOwnerId, instanceId);
if (instance == null)
{
return(NotFound());
}
// Todo. Figure out where to get this from
Dictionary <string, Dictionary <string, string> > serviceText = new Dictionary <string, Dictionary <string, string> >();
if (instance.Process?.CurrentTask?.ElementId == null)
{
throw new ValidationException("Unable to validate instance without a started process.");
}
List <ValidationIssue> messages = new List <ValidationIssue>();
DataElement element = instance.Data.FirstOrDefault(d => d.Id == dataGuid.ToString());
if (element == null)
{
throw new ValidationException("Unable to validate data element.");
}
Application application = _appResourceService.GetApplication();
DataType dataType = application.DataTypes.FirstOrDefault(et => et.Id == element.DataType);
if (dataType == null)
{
throw new ValidationException("Unknown element type.");
}
messages.AddRange(await _validationService.ValidateDataElement(instance, dataType, element));
string taskId = instance.Process.CurrentTask.ElementId;
if (!dataType.TaskId.Equals(taskId, StringComparison.OrdinalIgnoreCase))
{
ValidationIssue message = new ValidationIssue
{
Code = ValidationIssueCodes.DataElementCodes.DataElementValidatedAtWrongTask,
InstanceId = instance.Id,
Severity = ValidationIssueSeverity.Warning,
DataElementId = element.Id,
Description = AppTextHelper.GetAppText(
ValidationIssueCodes.DataElementCodes.DataElementValidatedAtWrongTask, serviceText, null, "nb")
};
messages.Add(message);
}
return(Ok(messages));
}
public IEnumerable <ValidationIssue> GetLatestValidationIssues(Package package)
{
// Only query the database for validation issues if the package has failed validation.
if (package.PackageStatusKey == PackageStatus.FailedValidation)
{
// Grab the most recently completed validation set for this package. Note that the orchestrator will stop
// processing a validation set if all validation succeed, OR, one or more validation fails.
var validationSet = _validationSets
.GetAll()
.Where(s => s.PackageKey == package.Key)
.Where(s => s.PackageValidations.All(v => v.ValidationStatus == ValidationStatus.Succeeded) ||
s.PackageValidations.Any(v => v.ValidationStatus == ValidationStatus.Failed))
.Include(s => s.PackageValidations.Select(v => v.PackageValidationIssues))
.OrderByDescending(s => s.Updated)
.FirstOrDefault();
if (validationSet != null)
{
// Get the failed validation set's validation issues. The issues are ordered by their
// key so that it appears that issues are appended as more validations fail.
return(validationSet
.PackageValidations
.SelectMany(v => v.PackageValidationIssues)
.OrderBy(i => i.Key)
.Select(i => ValidationIssue.Deserialize(i.IssueCode, i.Data))
.ToList());
}
}
return(Enumerable.Empty <ValidationIssue>());
}
private IReadOnlyList <ValidationIssue> GetValidationIssues(int entityKey, PackageStatus status, ValidatingType validatingType)
{
IReadOnlyList <ValidationIssue> issues = new ValidationIssue[0];
// Only query the database for validation issues if the package has failed validation.
if (status == PackageStatus.FailedValidation)
{
// Grab the most recently completed validation set for this package. Note that the orchestrator will stop
// processing a validation set if all validation succeed, OR, one or more validation fails.
var validationSet = _validationSets?
.GetAll()
.Where(s => s.PackageKey == entityKey && s.ValidatingType == validatingType)
.Where(s => s.PackageValidations.All(v => v.ValidationStatus == ValidationStatus.Succeeded) ||
s.PackageValidations.Any(v => v.ValidationStatus == ValidationStatus.Failed))
.Include(s => s.PackageValidations.Select(v => v.PackageValidationIssues))
.OrderByDescending(s => s.Updated)
.FirstOrDefault();
if (validationSet != null)
{
issues = validationSet.GetValidationIssues();
}
}
return(issues);
}
/// <summary>
/// Returns a Markdown representation describing the <see cref="ValidationIssue"/> in a user-friendly way.
/// </summary>
public static string ToMarkdownString(this ValidationIssue validationIssue, string announcementsUrl, string twitterUrl)
{
if (validationIssue == null)
{
throw new ArgumentNullException(nameof(validationIssue));
}
if (announcementsUrl == null)
{
throw new ArgumentNullException(nameof(announcementsUrl));
}
if (twitterUrl == null)
{
throw new ArgumentNullException(nameof(twitterUrl));
}
switch (validationIssue.IssueCode)
{
case ValidationIssueCode.PackageIsSigned:
return($"This package could not be published since it is signed. We do not accept signed packages at this moment. To be notified about package signing and more, watch our [Announcements]({announcementsUrl}) page or follow us on [Twitter]({twitterUrl}).");
case ValidationIssueCode.ClientSigningVerificationFailure:
var clientIssue = (ClientSigningVerificationFailure)validationIssue;
return(clientIssue != null
? $"**{clientIssue.ClientCode}**: {clientIssue.ClientMessage}"
: "This package's signature was unable to get verified.");
case ValidationIssueCode.PackageIsZip64:
return("Zip64 packages are not supported.");
case ValidationIssueCode.OnlyAuthorSignaturesSupported:
return("Signed packages must only have an author signature. Other signature types are not supported.");
case ValidationIssueCode.AuthorAndRepositoryCounterSignaturesNotSupported:
return("Author countersignatures and repository countersignatures are not supported.");
case ValidationIssueCode.OnlySignatureFormatVersion1Supported:
return("**NU3007:** Package signatures must have format version 1.");
case ValidationIssueCode.AuthorCounterSignaturesNotSupported:
return("Author countersignatures are not supported.");
case ValidationIssueCode.PackageIsNotSigned:
return("This package must be signed with a registered certificate. [Read more...](https://aka.ms/nuget-signed-ref)");
case ValidationIssueCode.PackageIsSignedWithUnauthorizedCertificate:
var certIssue = (UnauthorizedCertificateFailure)validationIssue;
return($"The package was signed, but the signing certificate {(certIssue != null ? $"(SHA-1 thumbprint {certIssue.Sha1Thumbprint})" : "")} is not associated with your account. You must register this certificate to publish signed packages. [Read more...](https://aka.ms/nuget-signed-ref)");
case ValidationIssueCode.SymbolErrorCode_ChecksumDoesNotMatch:
return("The checksum does not match for the dll(s) and corresponding pdb(s).");
case ValidationIssueCode.SymbolErrorCode_MatchingPortablePDBNotFound:
return("The uploaded symbols package contains pdb(s) for a corresponding dll(s) not found in the nuget package.");
default:
return("There was an unknown failure when validating your package.");
}
}
private List <ValidationIssue> MapModelStateToIssueList(
Instance instance,
List <System.ComponentModel.DataAnnotations.ValidationResult> validationResult,
string elementId,
string dataType,
Dictionary <string, Dictionary <string, string> > serviceText)
{
List <ValidationIssue> messages = new List <ValidationIssue>();
foreach (System.ComponentModel.DataAnnotations.ValidationResult validationIssue in validationResult)
{
if (validationIssue != null)
{
ValidationIssue message = new ValidationIssue
{
InstanceId = instance.Id,
DataElementId = elementId,
Code = validationIssue.ErrorMessage,
Field = string.Join(",", validationIssue.MemberNames),
Severity = ValidationIssueSeverity.Error,
Description = ServiceTextHelper.GetServiceText(validationIssue.ErrorMessage, serviceText, null, "nb")
};
messages.Add(message);
}
}
return(messages);
}
public void HasACaseForAllIssueTypes(ValidationIssue issue)
{
// Arrange & Act
var html = CompileView(issue);
// Assert
Assert.DoesNotContain(UnknownIssueMessage, html);
}
public void HasExpectedMessageForUnknownIssue(ValidationIssue issue)
{
// Arrange & Act
var html = CompileView(issue);
// Assert
Assert.Equal(UnknownIssueMessage, html);
}
public static void AddValidationIssues(this Dictionary<ILineItem, List<ValidationIssue>> issues, ILineItem lineItem, ValidationIssue issue)
{
if (!issues.ContainsKey(lineItem))
{
issues.Add(lineItem, new List<ValidationIssue>());
}
if (!issues[lineItem].Contains(issue))
{
issues[lineItem].Add(issue);
}
}
/// <summary>
/// Adds the issue.
/// </summary>
/// <param name="issue">The issue.</param>
public void AddIssue(ValidationIssue issue)
{
Check.ArgumentNotNull(issue, nameof(issue));
Check.ArgumentNotNull(issue.Resource, $"{nameof(issue)}.{nameof(issue.Resource)}");
Check.ArgumentNotEmpty(issue.Resource.ResourceID, $"{nameof(issue)}.{nameof(issue.Resource)}.{nameof(issue.Resource.ResourceID)}");
if (!_issues.ContainsKey(issue.Resource.ResourceID))
{
_issues[issue.Resource.ResourceID] = new Dictionary <ValidationIssue, ValidationIssue>();
}
_issues[issue.Resource.ResourceID][issue] = issue;
}
public static void AddValidationIssues(this Dictionary <ILineItem, List <ValidationIssue> > issues,
ILineItem lineItem, ValidationIssue issue)
{
if (!issues.ContainsKey(lineItem))
{
issues.Add(lineItem, new List <ValidationIssue>());
}
if (!issues[lineItem].Contains(issue))
{
issues[lineItem].Add(issue);
}
}
public void UnauthorizedCertificateFailureDeserialization()
{
// Arrange
var validationIssue = CreatePackageValidationIssue(ValidationIssueCode.PackageIsSignedWithUnauthorizedCertificate, Strings.UnauthorizedCertificateFailureIssueJson);
// Act
var result = ValidationIssue.Deserialize(validationIssue.IssueCode, validationIssue.Data) as UnauthorizedCertificateFailure;
// Assert
Assert.NotNull(result);
Assert.Equal(ValidationIssueCode.PackageIsSignedWithUnauthorizedCertificate, result.IssueCode);
Assert.Equal("thumbprint", result.Sha1Thumbprint);
}
public void InvalidDataDeserialization(ValidationIssueCode code, string data)
{
// Arrange
var validationIssue = CreatePackageValidationIssue(code, data);
// Act
var result = ValidationIssue.Deserialize(validationIssue.IssueCode, validationIssue.Data);
// Assert
Assert.NotNull(result);
Assert.Equal(ValidationIssueCode.Unknown, result.IssueCode);
Assert.Equal(Strings.EmptyJson, result.Serialize());
}
private bool Equals(ValidationIssue other)
{
if (other == null)
return false;
if (ReferenceEquals(this, other))
return true;
if (Severity != other.Severity)
return false;
if (!Equals(Subject, other.Subject))
return false;
if (!Equals(Message, other.Message))
return false;
return true;
}
public void ClientSigningVerificationFailureDeserialization()
{
// Arrange
var validationIssue = CreatePackageValidationIssue(ValidationIssueCode.ClientSigningVerificationFailure, Strings.ClientSigningVerificationFailureIssueJson);
// Act
var result = ValidationIssue.Deserialize(validationIssue.IssueCode, validationIssue.Data) as ClientSigningVerificationFailure;
// Assert
Assert.NotNull(result);
Assert.Equal(ValidationIssueCode.ClientSigningVerificationFailure, result.IssueCode);
Assert.Equal("NU3008", result.ClientCode);
Assert.Equal("The package integrity check failed.", result.ClientMessage);
}
public void DeserializationOfIssuesWithNoProperties(ValidationIssueCode code)
{
// Arrange
var validationIssue = CreatePackageValidationIssue(code, Strings.EmptyJson);
// Act
var result = ValidationIssue.Deserialize(validationIssue.IssueCode, validationIssue.Data);
// Assert
Assert.NotNull(result);
var issue = Assert.IsType <NoDataValidationIssue>(result);
Assert.Equal(code, result.IssueCode);
}
public void CanCreate()
{
var myMessage = "MyMessage";
var myPropertyName = "MyPropertyName";
var myAttemptedValue = "myAttemptedValue";
var validationIssue = new ValidationIssue(myMessage);
validationIssue.Message.Should().Be.EqualTo(myMessage);
validationIssue.PropertyName.Should().Be.Null();
validationIssue.AttemptedValue.Should().Be.Null();
validationIssue = new ValidationIssue(myMessage, myPropertyName, myAttemptedValue);
validationIssue.Message.Should().Be.EqualTo(myMessage);
validationIssue.PropertyName.Should().Be.EqualTo(myPropertyName);
validationIssue.AttemptedValue.Should().Be.EqualTo(myAttemptedValue);
}
private void TrackValidationStatus(PackageValidation packageValidation)
{
if (packageValidation.ValidationStatus != ValidationStatus.Failed &&
packageValidation.ValidationStatus != ValidationStatus.Succeeded)
{
return;
}
var isSuccess = packageValidation.ValidationStatus == ValidationStatus.Succeeded;
TimeSpan validatorDuration = TimeSpan.Zero;
if (packageValidation.Started.HasValue)
{
validatorDuration = packageValidation.ValidationStatusTimestamp - packageValidation.Started.Value;
}
var validationSet = packageValidation.PackageValidationSet;
_telemetryService.TrackValidatorDuration(
validationSet.PackageId,
validationSet.PackageNormalizedVersion,
validationSet.ValidationTrackingId,
validatorDuration,
packageValidation.Type,
isSuccess);
var issues = (packageValidation.PackageValidationIssues ?? Enumerable.Empty <PackageValidationIssue>()).ToList();
_telemetryService.TrackValidationIssueCount(
validationSet.PackageId,
validationSet.PackageNormalizedVersion,
validationSet.ValidationTrackingId,
issues.Count,
packageValidation.Type,
isSuccess);
foreach (var issue in issues)
{
_telemetryService.TrackValidationIssue(validationSet.PackageId, validationSet.PackageNormalizedVersion, validationSet.ValidationTrackingId, packageValidation.Type, issue.IssueCode);
var deserializedIssue = ValidationIssue.Deserialize(issue.IssueCode, issue.Data);
if (issue.IssueCode == ValidationIssueCode.ClientSigningVerificationFailure &&
deserializedIssue is ClientSigningVerificationFailure typedIssue)
{
_telemetryService.TrackClientValidationIssue(validationSet.PackageId, validationSet.PackageNormalizedVersion, validationSet.ValidationTrackingId, packageValidation.Type, typedIssue.ClientCode);
}
}
}
public void CanCreate()
{
var myMessage = "MyMessage";
var myPropertyName = "MyPropertyName";
var myAttemptedValue = "myAttemptedValue";
var validationIssue = new ValidationIssue(myMessage);
validationIssue.Message.Should().Be.EqualTo(myMessage);
validationIssue.PropertyName.Should().Be.Null();
validationIssue.AttemptedValue.Should().Be.Null();
validationIssue = new ValidationIssue(myMessage, myPropertyName, myAttemptedValue);
validationIssue.Message.Should().Be.EqualTo(myMessage);
validationIssue.PropertyName.Should().Be.EqualTo(myPropertyName);
validationIssue.AttemptedValue.Should().Be.EqualTo(myAttemptedValue);
}
public IReadOnlyList <ValidationIssue> GetLatestValidationIssues(Package package)
{
var issues = Enumerable.Empty <ValidationIssue>();
// Only query the database for validation issues if the package has failed validation.
if (package.PackageStatusKey == PackageStatus.FailedValidation)
{
// Grab the most recently completed validation set for this package. Note that the orchestrator will stop
// processing a validation set if all validation succeed, OR, one or more validation fails.
var validationSet = _validationSets
.GetAll()
.Where(s => s.PackageKey == package.Key)
.Where(s => s.PackageValidations.All(v => v.ValidationStatus == ValidationStatus.Succeeded) ||
s.PackageValidations.Any(v => v.ValidationStatus == ValidationStatus.Failed))
.Include(s => s.PackageValidations.Select(v => v.PackageValidationIssues))
.OrderByDescending(s => s.Updated)
.FirstOrDefault();
if (validationSet != null)
{
// Get the failed validation set's validation issues. The issues are ordered by their
// key so that it appears that issues are appended as more validations fail.
issues = validationSet
.PackageValidations
.SelectMany(v => v.PackageValidationIssues)
.OrderBy(i => i.Key)
.Select(i => ValidationIssue.Deserialize(i.IssueCode, i.Data))
.ToList();
}
// If the package failed validation, use the generic error message.
if (issues == null || !issues.Any())
{
issues = new[] { ValidationIssue.Unknown };
}
}
// Filter out unknown issues and deduplicate the issues by code and data. This also deduplicates cases
// where there is extraneous data in the serialized data field or if the issue code is unknown to the
// gallery.
return(issues
.GroupBy(x => new { x.IssueCode, Data = x.Serialize() })
.Select(x => x.First())
.ToList());
}
public void ObsoleteTestingIssueDeserialization()
{
// Arrange
#pragma warning disable 618
var validationIssue = CreatePackageValidationIssue(ValidationIssueCode.ObsoleteTesting, Strings.ObsoleteTestingIssueJson);
// Act
var result = ValidationIssue.Deserialize(validationIssue.IssueCode, validationIssue.Data) as ObsoleteTestingIssue;
#pragma warning restore 618
// Assert
Assert.NotNull(result);
#pragma warning disable 618
Assert.Equal(ValidationIssueCode.ObsoleteTesting, result.IssueCode);
#pragma warning restore 618
Assert.Equal("Hello", result.A);
Assert.Equal(123, result.B);
}
// Process the validation and get the list of validation issues.
private static void GetBRValidationIssue(string modelName, string entityName, string ruleName, string versionName)
{
try
{
// Set Model, Entity, and Version objects.
Identifier modelId = new Identifier {
Name = modelName
};
Identifier entityId = new Identifier {
Name = entityName
};
Identifier versionId = new Identifier {
Name = versionName
};
// Create the request object.
MDSTestService.ValidationProcessRequest validationProcessRequest = new MDSTestService.ValidationProcessRequest();
validationProcessRequest.ValidationProcessCriteria = new ValidationProcessCriteria();
validationProcessRequest.ValidationProcessCriteria.ModelId = modelId;
validationProcessRequest.ValidationProcessCriteria.EntityId = entityId;
validationProcessRequest.ValidationProcessCriteria.VersionId = versionId;
validationProcessRequest.ValidationProcessOptions = new ValidationProcessOptions();
validationProcessRequest.ValidationProcessOptions.ReturnValidationResults = true;
// Process validation and get a validation issue.
MDSTestService.ValidationProcessResponse validationProcessResponse = clientProxy.ValidationProcess(validationProcessRequest);
HandleOperationErrors(validationProcessResponse.OperationResult);
// Show the validation issue's description.
if (validationProcessResponse.ValidationIssueList.Count > 0)
{
ValidationIssue validationIssue = validationProcessResponse.ValidationIssueList[0];
Console.WriteLine("Validation issue: " + validationIssue.Description);
}
}
catch (Exception ex)
{
Console.WriteLine("Error: {0}", ex);
}
}
private static string ParseValidationIssue(ValidationIssue validationIssue, string announcementsUrl, string twitterUrl)
{
switch (validationIssue.IssueCode)
{
case ValidationIssueCode.PackageIsSigned:
return($"This package could not be published since it is signed. We do not accept signed packages at this moment. To be notified about package signing and more, watch our [Announcements]({announcementsUrl}) page or follow us on [Twitter]({twitterUrl}).");
case ValidationIssueCode.ClientSigningVerificationFailure:
var clientIssue = (ClientSigningVerificationFailure)validationIssue;
return(clientIssue != null
? $"**{clientIssue.ClientCode}**: {clientIssue.ClientMessage}"
: "This package's signature was unable to be verified.");
case ValidationIssueCode.PackageIsZip64:
return("Zip64 packages are not supported.");
case ValidationIssueCode.OnlyAuthorSignaturesSupported:
return("Signed packages must only have an author signature. Other signature types are not supported.");
case ValidationIssueCode.AuthorAndRepositoryCounterSignaturesNotSupported:
return("Author countersignatures and repository countersignatures are not supported.");
case ValidationIssueCode.OnlySignatureFormatVersion1Supported:
return("**NU3007:** Package signatures must have format version 1.");
case ValidationIssueCode.AuthorCounterSignaturesNotSupported:
return("Author countersignatures are not supported.");
case ValidationIssueCode.PackageIsNotSigned:
return("This package must be signed with a registered certificate. [Read more...](https://aka.ms/nuget-signed-ref)");
case ValidationIssueCode.PackageIsSignedWithUnauthorizedCertificate:
var certIssue = (UnauthorizedCertificateFailure)validationIssue;
return($"The package was signed, but the signing certificate {(certIssue != null ? $"(SHA-1 thumbprint {certIssue.Sha1Thumbprint})" : "")} is not associated with your account. You must register this certificate to publish signed packages. [Read more...](https://aka.ms/nuget-signed-ref)");
default:
return("There was an unknown failure when validating your package.");
}
}
private bool Equals(ValidationIssue other)
{
if (other == null)
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
if (Severity != other.Severity)
{
return(false);
}
if (!Equals(Subject, other.Subject))
{
return(false);
}
if (!Equals(Message, other.Message))
{
return(false);
}
return(true);
}
public BaseResponse(IEnumerable <ValidationFailure> failures)
{
isSuccess = false;
ValidationIssues = new List <ValidationIssue>();
var propertyNames = failures
.Select(e => e.PropertyName)
.Distinct();
foreach (var propertyName in propertyNames)
{
// Each PropertyName get's an array of failures associated with it:
var PropertyFailures = failures
.Where(e => e.PropertyName == propertyName)
.Select(e => e.ErrorMessage)
.ToArray();
var propertyFailure = new ValidationIssue {
PropertyName = propertyName, PropertyFailures = PropertyFailures.ToList()
};
ValidationIssues.Add(propertyFailure);
}
}
private string CompileView(ValidationIssue issue)
{
// Arrange
var config = new TemplateServiceConfiguration
{
TemplateManager = new EmbeddedResourceTemplateManager(GetType()),
DisableTempFileLocking = true,
};
using (var razorEngine = RazorEngineService.Create(config))
{
_output.WriteLine($"Issue code: {issue.IssueCode}");
_output.WriteLine($"Serialized: {issue.Serialize()}");
// Act
var html = CollapseWhitespace(razorEngine.RunCompile("_ValidationIssue", model: issue))
.Trim();
_output.WriteLine($"HTML:");
_output.WriteLine(html);
return(html);
}
}
public async Task <List <ValidationIssue> > ValidateAndUpdateProcess(Instance instance, string taskId)
{
// Todo. Figure out where to get this from
Dictionary <string, Dictionary <string, string> > serviceText = new Dictionary <string, Dictionary <string, string> >();
_logger.LogInformation($"Validation of {instance.Id}");
List <ValidationIssue> messages = new List <ValidationIssue>();
ModelStateDictionary validationResults = new ModelStateDictionary();
await _altinnApp.RunTaskValidation(instance, taskId, validationResults);
messages.AddRange(MapModelStateToIssueList(validationResults, instance, serviceText));
Application application = _appResourcesService.GetApplication();
foreach (DataType dataType in application.DataTypes.Where(et => et.TaskId == taskId))
{
List <DataElement> elements = instance.Data.Where(d => d.DataType == dataType.Id).ToList();
if (dataType.MaxCount > 0 && dataType.MaxCount < elements.Count)
{
ValidationIssue message = new ValidationIssue
{
InstanceId = instance.Id,
Code = ValidationIssueCodes.InstanceCodes.TooManyDataElementsOfType,
Severity = ValidationIssueSeverity.Error,
Description = AppTextHelper.GetAppText(
ValidationIssueCodes.InstanceCodes.TooManyDataElementsOfType, serviceText, null, "nb"),
Field = dataType.Id
};
messages.Add(message);
}
if (dataType.MinCount > 0 && dataType.MinCount > elements.Count)
{
ValidationIssue message = new ValidationIssue
{
InstanceId = instance.Id,
Code = ValidationIssueCodes.InstanceCodes.TooFewDataElementsOfType,
Severity = ValidationIssueSeverity.Error,
Description = AppTextHelper.GetAppText(
ValidationIssueCodes.InstanceCodes.TooFewDataElementsOfType, null, null, "nb"),
Field = dataType.Id
};
messages.Add(message);
}
foreach (DataElement dataElement in elements)
{
messages.AddRange(await ValidateDataElement(instance, dataType, dataElement));
}
}
if (messages.Count == 0)
{
instance.Process.CurrentTask.Validated = new ValidationStatus {
CanCompleteTask = true, Timestamp = DateTime.Now
};
}
else
{
instance.Process.CurrentTask.Validated = new ValidationStatus {
CanCompleteTask = false, Timestamp = DateTime.Now
};
}
instance = await _instanceService.UpdateProcess(instance);
return(messages);
}
private void ProcessValidationIssue(ILineItem lineItem, ValidationIssue issue)
{
}
private void AddValidationIssues(IDictionary <ILineItem, IList <ValidationIssue> > issues, ILineItem lineItem, ValidationIssue issue)
{
if (!issues.ContainsKey(lineItem))
{
issues.Add(lineItem, new List <ValidationIssue>());
}
if (!issues[lineItem].Contains(issue))
{
issues[lineItem].Add(issue);
}
}
private static string CreateValidationMessages(ILineItem item, ValidationIssue issue)
{
return(string.Format("Line item with code {0} had the validation issue {1}.", item.Code, issue));
}
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 void AddIssue(ValidationIssue issue)
{
Issues.Add(issue);
}
public ValidationIssueException(ValidationIssue validationIssue) : base()
{
ValidationIssues = new List <ValidationIssue>();
ValidationIssues.Add(validationIssue);
}
