/// <inheritdoc />
public List <Error> Validate(DynamicMetadata dynamicMetadata, Movie context)
{
List <Error> errors = new List <Error>();
foreach (var validator in _validators)
{
errors.AddRange(validator.Validate(dynamicMetadata, context));
}
return(errors);
}
/// <inheritdoc />
public List <Error> Validate(DynamicMetadata dynamicMetadata, Movie context)
{
var property = dynamicMetadata.Properties.First(x => x.Id == Property);
if (property.Value != null)
{
return(new List <Error>());
}
return(new List <Error>
{
new Error(102312, "Null value")
});
}
/// <inheritdoc />
public List <Error> Validate(DynamicMetadata dynamicMetadata, Movie context)
{
var property = dynamicMetadata.Properties.First(x => x.Id == Property);
int value = (int)property.Value;
if (value > MaxRange)
{
return(new List <Error>
{
new Error((int)ErrorCodes.NumericPropertyValidator.MaxValueExceeded, ErrorCodes.NumericPropertyValidator.MaxValueExceeded.GetDescription())
});
}
return(new List <Error>());
}
/// <inheritdoc />
public List <Error> Validate(DynamicMetadata dynamicMetadata, Movie context)
{
var property = dynamicMetadata.Properties.First(x => x.Id == Property);
if (property.Value != null)
{
Model.Person value = (Model.Person)property.Value;
var dbItem = _personReadService.GetById(value.Id);
if (dbItem == null)
{
return(new List <Error>
{
new Error(23123123, "Person doesnt exist")
});
}
}
return(new List <Error>());
}
/// <inheritdoc />
public List <Error> Validate(DynamicMetadata dynamicMetadata, Movie context)
{
var existingItems = context.Metadata.Where(x => x.DefinitionId == dynamicMetadata.DefinitionId).ToList();
bool isApplied = true;
foreach (var item in existingItems)
{
if (item.Id != dynamicMetadata.Id)
{
isApplied = false;
}
}
if (!isApplied && existingItems.Any())
{
return(new List <Error>
{
new Error((int)ErrorCodes.GenericValidator.ReachedMaxItemsOfThisType, ErrorCodes.GenericValidator.ReachedMaxItemsOfThisType.GetDescription())
});
}
return(new List <Error>());
}
/// <inheritdoc />
public async Task <DynamicMetadataDto> HandleResult(CreateMovieMetadataCommand command, CancellationToken token)
{
var movie = _movieReadService.GetById(command.MovieId);
if (movie == null)
{
throw new NotFoundException();
}
var definition = _dynamicMetadataDefinitionReadService.GetById(command.Metadata.MetadataDefinitionId);
if (definition == null)
{
throw new NotFoundException();
}
var validator = _validatorFactory.GetValidator(definition);
var metadata = new DynamicMetadata
{
DefinitionId = command.Metadata.MetadataDefinitionId,
Id = Guid.NewGuid().ToString()
};
foreach (var metadataEntry in command.Metadata.DynamicProperties)
{
var propertyDefinition = definition.Properties.SingleOrDefault(x => x.Id == metadataEntry.Id);
if (propertyDefinition != null)
{
if (propertyDefinition.Type != metadataEntry.Type)
{
throw new AggregatedValidationException("Type mismatch")
{
ErrorCode = 11231,
ValidationErrors = new List <Error>()
};
}
var existingMetadata = metadata.Properties.SingleOrDefault(x => x.Id == metadataEntry.Id);
if (existingMetadata == null)
{
try
{
var parsedValue = _inputDataParser.DeserializeItem(metadataEntry.Id, metadataEntry.Type,
metadataEntry.Value);
metadata.Properties.Add(parsedValue);
}
catch (JsonException exception)
{
throw new AggregatedValidationException("Invalid type mismatch")
{
ErrorCode = 11231,
ValidationErrors = new List <Error>()
};
}
}
}
}
foreach (var propertyInDefinition in definition.Properties)
{
var existingProperty = metadata.Properties.FirstOrDefault(x => x.Id == propertyInDefinition.Id);
if (existingProperty == null)
{
metadata.Properties.Add(propertyInDefinition);
}
}
var validationResult = validator.Validate(metadata, movie);
if (validationResult.Any())
{
throw new AggregatedValidationException("Validation exception")
{
ErrorCode = 1,
ValidationErrors = validationResult
};
}
movie.Metadata.Add(metadata);
_movieWriteService.UpdateItem(movie, token);
var resultValue = _mapper.Map <DynamicMetadataDto>(metadata);
return(resultValue);
}
