public async Task RelatedBasic()
{
var sheet = Utils.GetSheet(2, "items",
new object[] { "number", "name", "country_code", "quantity" });
var request = new SheetOnTypeParseRequest
{
MappingOptions = SheetMappingOptions.Default(sheet.Index),
NamingStrategy = JsonNamingStrategy.SnakeCase,
RootType = typeof(Order),
Sheet = sheet
};
var svc = new ExcelSheetOnTypeValidator();
var result = await svc.Validate(request);
Assert.AreEqual(false, result.HasErrors);
Assert.AreEqual(true, result.IgnoreFirstRow);
Assert.AreEqual(0, result.InvalidHeaders.Length);
Assert.AreEqual(false, result.InvalidName);
var map = sheet.Header.Select(c => c.Value.ToString()).ToArray();
for (int i = 0; i < map.Length; i++)
{
Assert.AreEqual(map[i], result.Map[i]);
}
}
public override async Task <ExcelFileRecord> Load(string url, TypedParseToJsonOptions options)
{
var container = await reader.Load(url, options.SheetsOptions);
var validationResult = new Dictionary <int, SheetValidationResult>();
var sheets = container.Sheets;
foreach (var sheet in sheets)
{
var sheetOptions = GetOptions(sheet, options);
var request = new SheetOnTypeParseRequest
{
LongName = sheetOptions?.SheetName,
MappingOptions = sheetOptions,
NamingStrategy = options.NamingStrategy,
RootType = options.OnType(),
Sheet = sheet
};
var result = await sheetValidator.Validate(request);
validationResult[sheet.Index] = result;
}
return(new ExcelFileRecord(url, sheets, validationResult, options));
}
public async Task <SheetValidationResult> Validate(string url, int sheetIndex = 0,
JsonNamingStrategy jsonNamingStrategy = JsonNamingStrategy.None,
string[] headerMap = null, bool ignoreFirstRow = true)
{
loaded = true;
ignoreFirst = ignoreFirstRow;
namingStrategy = jsonNamingStrategy;
map = headerMap;
var sheet = await reader.LoadSheet(url, sheetIndex, map);
if (sheet == null)
{
return(SheetValidationResult.SheetNotPresent());
}
var request = new SheetOnTypeParseRequest
{
MappingOptions = new SheetMappingOptions
{
Ignore = ignoreFirst,
Map = headerMap,
IndexAsId = true
},
NamingStrategy = namingStrategy,
RootType = typeof(T),
Sheet = sheet
};
sheetValidationResult = await sheetValidator.Validate(request);
return(sheetValidationResult);
}
public Task <SheetValidationResult> Validate(SheetOnTypeParseRequest request)
{
var sheet = request.Sheet;
if (sheet.Empty || sheet.EmptyData)
{
return(Task.FromResult(SheetValidationResult.EmptySheet()));
}
var invalidName = false;
var invalidHeaders = new List <int>();
Type type = null;
var sheetOptions = request.MappingOptions;
var(ignoreFirstRow, headerMap) = GetMap(sheet, sheetOptions);
if (sheet.Index == 0)
{
type = request.RootType;
invalidName = false;
}
else
{
type = GetEnumerableType(request.RootType,
request.LongName ?? sheet.Name, request.NamingStrategy);
invalidName = type == null;
}
if (!invalidName)
{
var idHeaders = new List <int>();
if (request.MappingOptions.IdIndex.HasValue)
{
idHeaders.Add(request.MappingOptions.IdIndex.Value);
}
if (request.MappingOptions.ParentIdIndex.HasValue)
{
idHeaders.Add(request.MappingOptions.ParentIdIndex.Value);
}
for (var i = 0; i < headerMap.Length; i++)
{
if (idHeaders.Contains(i))
{
continue;
}
if (string.IsNullOrEmpty(headerMap[i]))
{
invalidHeaders.Add(i);
continue;
}
var propertyName = headerMap[i].Transform(request.NamingStrategy);
var propertyPath = PropertyPath.TryParse(type, propertyName);
if (propertyPath == null)
{
invalidHeaders.Add(i);
}
else
{
var enumerableType = GetEnumerableType(type, propertyName, request.NamingStrategy);
if (enumerableType != null && !AllowedEnumerableInSheet(enumerableType))
{
invalidHeaders.Add(i);
}
}
}
}
var result = new SheetValidationResult(headerMap, ignoreFirstRow, invalidName, invalidHeaders.ToArray());
return(Task.FromResult(result));
}
