protected override DetailedValidationResult ValidateDto(UserDto dto)
{
var lang = _userProvider.GetCurrentUser()?.Language;
DetailedValidationResult result = base.ValidateDto(dto);
if (string.IsNullOrEmpty(dto.Id) && string.IsNullOrEmpty(dto.Password))
{
result.AddError(nameof(dto.Password), "User.Password.ValueIsRequired".Translate(lang),
ValidationErrorType.ValueIsRequired);
}
var hasDuplicates = this._dataService.GetDbSet <User>()
.Where(i => i.Id != dto.Id.ToGuid())
.Where(i => i.Email == dto.Email)
.Any();
if (hasDuplicates)
{
result.AddError(nameof(dto.Email), "User.DuplicatedRecord".Translate(lang),
ValidationErrorType.DuplicatedRecord);
}
return(result);
}
public IEnumerable <ValidatedRecord <TDto> > LoadEntries(ExcelWorksheet worksheet)
{
var rows = worksheet.Cells
.Select(cell => cell.Start.Row)
.Distinct()
.OrderBy(x => x);
if (!rows.Any())
{
yield break;
}
int headRowIndex = rows.First();
int maxColumnInd = worksheet.Cells.Select(c => c.End.Column).Max();
List <string> columnTitles = new List <string>();
for (int colIndex = 1; colIndex <= maxColumnInd; colIndex++)
{
columnTitles.Add(worksheet.Cells[headRowIndex, colIndex]?.Value?.ToString());
}
columnTitles = Unlocalize(columnTitles, _columns.Values.Select(x => x.Field)).ToList();
FillColumnOrder(columnTitles);
foreach (int rowIndex in rows.Skip(1))
{
bool isEmpty = IsEmptyRow(worksheet, rowIndex);
if (isEmpty)
{
continue;
}
var entity = new TDto();
var validationResult = new DetailedValidationResult();
foreach (var column in _columns.Values)
{
try
{
var cell = worksheet.Cells[rowIndex, column.ColumnIndex];
var columnResult = column.SetValue(entity, cell);
if (columnResult != null)
{
validationResult.AddError(_columns.Keys.ElementAt(column.ColumnIndex), columnResult.Message, columnResult.ResultType);
}
}
catch (Exception ex)
{
validationResult.AddError("exception", $"Строка {rowIndex}: {ex.Message}.", ValidationErrorType.Exception);
}
}
;
_errors.Add(validationResult);
yield return(new ValidatedRecord <TDto>(entity, validationResult));
}
}
/// <summary>
/// Validate Dto
/// </summary>
/// <typeparam name="TDto"></typeparam>
/// <param name="dto"></param>
/// <returns></returns>
public DetailedValidationResult Validate <TDto>(TDto dto)
{
var prefix = typeof(TDto).Name.Replace("Dto", "");
var fields = this._fieldDispatcher.GetDtoFields <TDto>();
var lang = _userProvider.GetCurrentUser()?.Language;
var validationResult = new DetailedValidationResult();
foreach (var field in fields)
{
var property = typeof(TDto).GetProperty(field.Name);
var value = property.GetValue(dto)?.ToString();
var propertyName = property.Name.ToLowerFirstLetter();
var propertyDisplayName = propertyName.Translate(lang);
// Validate format
if (!ValidatePropertyFormat(field, value))
{
validationResult.AddError(new ValidationResultItem
{
Name = propertyName,
Message = "InvalidValueFormat".Translate(lang, propertyDisplayName),
ResultType = ValidationErrorType.InvalidValueFormat
});
}
// Validate IsRequred
if (!this.ValidateIsRequired(field, value))
{
validationResult.AddError(new ValidationResultItem
{
Name = propertyName,
Message = "ValueIsRequired".Translate(lang, propertyDisplayName),
ResultType = ValidationErrorType.ValueIsRequired
});
}
if (field.FieldType == FieldType.Password)
{
var result = ValidatePassword(field, value, prefix, lang);
if (result != null)
{
validationResult.AddError(result);
}
}
}
return(validationResult);
}
protected override DetailedValidationResult ValidateDto(TonnageDto dto)
{
var lang = _userProvider.GetCurrentUser()?.Language;
DetailedValidationResult result = base.ValidateDto(dto);
var hasDuplicates = !result.IsError && _dataService.GetDbSet <Tonnage>()
.Any(x => x.Name == dto.Name && x.Id.ToString() != dto.Id);
if (hasDuplicates)
{
result.AddError(nameof(dto.Name), "Tonnage.DuplicatedRecord".Translate(lang), ValidationErrorType.DuplicatedRecord);
}
return(result);
}
protected override DetailedValidationResult ValidateDto(TransportCompanyDto dto)
{
var lang = _userProvider.GetCurrentUser()?.Language;
DetailedValidationResult result = base.ValidateDto(dto);
var hasDuplicates = _dataService.GetDbSet <TransportCompany>()
.Where(x => !string.IsNullOrEmpty(dto.Title) && x.Title.ToLower() == dto.Title.ToLower())
.Any(x => x.Id.ToString() != dto.Id);
if (hasDuplicates)
{
result.AddError(nameof(dto.Title), "TransportCompany.DuplicatedRecord".Translate(lang),
ValidationErrorType.DuplicatedRecord);
}
return(result);
}
protected override DetailedValidationResult ValidateDto(RoleDto dto)
{
var lang = _userProvider.GetCurrentUser()?.Language;
DetailedValidationResult result = base.ValidateDto(dto);
var hasDuplicates = !result.IsError && this._dataService.GetDbSet <Role>()
.Where(i => i.Id != dto.Id.ToGuid())
.Where(i => i.Name == dto.Name)
.Any();
if (hasDuplicates)
{
result.AddError(nameof(dto.Name), "Role.DuplicatedRecord".Translate(lang),
ValidationErrorType.DuplicatedRecord);
}
return(result);
}
public IEnumerable <ValidatedRecord <TFormDto> > LoadEntries(ExcelWorksheet worksheet)
{
var rows = worksheet.Cells
.Select(cell => cell.Start.Row)
.Distinct()
.OrderBy(x => x);
if (!rows.Any())
{
yield break;
}
int headRowIndex = rows.First();
int maxColumnInd = worksheet.Cells.Select(c => c.End.Column).Max();
List <string> columnTitles = new List <string>();
for (int colIndex = 1; colIndex <= maxColumnInd; colIndex++)
{
columnTitles.Add(worksheet.Cells[headRowIndex, colIndex]?.Value?.ToString());
}
var formType = typeof(TDto).Name;
var formTypeTranslates = _translations.Where(t => t.Name == formType).Select(_ => _.Ru);
formTypeTranslates =
formTypeTranslates.Concat(_translations.Where(t => t.Name == formType).Select(_ => _.En));
var columnFormTitles = columnTitles.Where(x => formTypeTranslates.Any(t => x.Contains(_delimeter + t)))
.Select(_ => _.Split(_delimeter).FirstOrDefault());
columnFormTitles = Unlocalize(columnFormTitles, _columns.Values.Select(x => x.Field)).ToList();
var formInnerType = typeof(TInnerDto).Name;
var formInnerTypeTranslates = _translations.Where(t => t.Name == formInnerType).Select(_ => _.Ru);
formInnerTypeTranslates =
formInnerTypeTranslates.Concat(_translations.Where(t => t.Name == formInnerType).Select(_ => _.En));
var columnInnerTitles = columnTitles
.Where(x => formInnerTypeTranslates.Any(t => x.Contains(_delimeter + t)))
.Select(_ => _.Split(_delimeter).FirstOrDefault());
columnInnerTitles = Unlocalize(columnInnerTitles, _columns.Values.Select(x => x.Field)).ToList();
columnTitles = columnFormTitles.Select(c => formType.ToLower() + '_' + c)
.Concat(columnInnerTitles.Select(ci => formInnerType.ToLower() + '_' + ci)).ToList();
FillColumnOrder(columnTitles);
var formColumns = _columns.Where(_ => _.Value.Property.DeclaringType.Name != typeof(TInnerDto).Name)
.ToDictionary(_ => _.Key, _ => _.Value);
var formInnerColumns = _columns.Where(_ => _.Value.Property.DeclaringType.Name == typeof(TInnerDto).Name)
.ToDictionary(_ => _.Key, _ => _.Value);
var entity = new TFormDto();
var innerList = new List <TInnerDto>();
var emptyFormRow = false;
var validationResult = new DetailedValidationResult();
foreach (int rowIndex in rows.Skip(1))
{
bool isEmpty = IsEmptyRow(worksheet, rowIndex, _columns);
if (isEmpty)
{
continue;
}
bool isEmptyForm = IsEmptyRow(worksheet, rowIndex, formColumns);
if (!isEmptyForm && rowIndex != headRowIndex + 1)
{
if (innerList.Any())
{
typeof(TFormDto).GetProperty(_innerFieldName).SetValue(entity, innerList);
innerList = new List <TInnerDto>();
}
yield return(new ValidatedRecord <TFormDto>(entity, validationResult));
entity = new TFormDto();
validationResult = new DetailedValidationResult();
}
bool isEmptyInnerForm = IsEmptyRow(worksheet, rowIndex, formInnerColumns);
var innerEntity = new TInnerDto();
var columnsToSeek = isEmptyForm ? formInnerColumns : _columns;
foreach (var column in columnsToSeek.Values)
{
try
{
var cell = worksheet.Cells[rowIndex, column.ColumnIndex];
ValidationResultItem columnResult;
if (column.Property.DeclaringType != typeof(TInnerDto))
{
columnResult = column.SetValue(entity, cell);
}
else if (!isEmptyInnerForm)
{
columnResult = column.SetValue(innerEntity, cell);
}
else
{
continue;
}
if (columnResult != null)
{
validationResult.AddError(_columns.Keys.ElementAt(column.ColumnIndex), columnResult.Message,
columnResult.ResultType);
}
}
catch (Exception ex)
{
validationResult.AddError("exception", $"Строка {rowIndex}: {ex.Message}.",
ValidationErrorType.Exception);
}
}
if (!isEmptyInnerForm)
{
innerList.Add(innerEntity);
}
_errors.Add(validationResult);
if (rowIndex == rows.Last())
{
if (innerList.Any())
{
typeof(TFormDto).GetProperty(_innerFieldName).SetValue(entity, innerList);
innerList = new List <TInnerDto>();
}
yield return(new ValidatedRecord <TFormDto>(entity, validationResult));
entity = new TFormDto();
}
}
}
