public async Task <bool> Import(SheetConvertingContext context)
{
var success = await LoadData();
if (!success)
{
context.Logger.LogError($"Failed to load data");
return(false);
}
var sheetProps = context.Container.GetSheetProperties();
foreach (var prop in sheetProps)
{
using (context.Logger.BeginScope(prop.Name))
{
var page = GetPage(prop.Name);
if (page == null)
{
context.Logger.LogError("Failed to find sheet: {SheetName}", prop.Name);
continue;
}
var sheet = Activator.CreateInstance(prop.PropertyType) as ISheet;
page.Import(this, context, sheet);
prop.SetValue(context.Container, sheet);
}
}
return(true);
}
public override void PostLoad(SheetConvertingContext context)
{
base.PostLoad(context);
int.TryParse(Value, out valueInt);
float.TryParse(Value, out valueFloat);
}
public async Task <bool> Export(SheetConvertingContext context)
{
foreach (var prop in context.Container.GetSheetProperties())
{
using (context.Logger.BeginScope(prop.Name))
{
var sheet = prop.GetValue(context.Container) as ISheet;
if (sheet == null)
{
continue;
}
var page = CreatePage(sheet.Name);
page.Export(this, context, sheet);
}
}
var success = await SaveData();
if (!success)
{
context.Logger.LogError($"Failed to save data");
return(false);
}
return(true);
}
private static void ImportToObject(this IRawSheetImporterPage page, RawSheetImporter importer, SheetConvertingContext context, object obj, int pageRow)
{
var type = obj.GetType();
var bindingFlags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.SetProperty;
for (int pageColumn = 0; !page.IsEmptyCell(pageColumn, 0); ++pageColumn)
{
var columnValue = page.GetCell(pageColumn, 0);
using (context.Logger.BeginScope(columnValue))
{
var cellValue = page.GetCell(pageColumn, pageRow);
if (string.IsNullOrEmpty(cellValue))
{
continue;
}
var prop = type.GetProperty(columnValue, bindingFlags);
if (prop == null)
{
continue;
}
try
{
object value = importer.StringToValue(prop.PropertyType, cellValue);
prop.SetValue(obj, value);
}
catch (Exception ex)
{
context.Logger.LogError(ex, "Failed to convert value \"{CellValue}\" of type {PropertyType}", cellValue, prop.PropertyType);
}
}
}
}
public static void Import(this IRawSheetImporterPage page, RawSheetImporter importer, SheetConvertingContext context, ISheet sheet)
{
var idColumnName = page.GetCell(0, 0);
if (idColumnName != nameof(ISheetRow.Id))
{
context.Logger.LogError("First column \"{ColumnName}\" must be named \"Id\"", idColumnName);
return;
}
ISheetRow sheetRow = null;
for (int pageRow = 1; !page.IsEmptyRow(pageRow); ++pageRow)
{
var rowId = page.GetCell(0, pageRow);
if (!string.IsNullOrEmpty(rowId))
{
using (context.Logger.BeginScope(rowId))
{
sheetRow = Activator.CreateInstance(sheet.RowType) as ISheetRow;
page.ImportToObject(importer, context, sheetRow, pageRow);
if (sheet.Contains(sheetRow.Id))
{
context.Logger.LogError("Already has row with id \"{RowId}\"", sheetRow.Id);
sheetRow = null;
}
else
{
sheet.Add(sheetRow);
}
}
}
if (sheetRow is ISheetRowArray sheetRowArray)
{
using (context.Logger.BeginScope(sheetRow.Id))
using (context.Logger.BeginScope(sheetRowArray.Arr.Count))
{
var sheetElem = Activator.CreateInstance(sheetRowArray.ElemType);
page.ImportToObject(importer, context, sheetElem, pageRow);
sheetRowArray.Arr.Add(sheetElem);
}
}
}
}
public static void Export(this IRawSheetExporterPage page, RawSheetConverter exporter, SheetConvertingContext context, ISheet sheet)
{
if (sheet.Count == 0)
{
return;
}
var bindingFlags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.SetProperty;
PropertyInfo[] sheetRowProperties = null, sheetElemProperties = null;
int pageRow = 1;
foreach (ISheetRow sheetRow in sheet)
{
using (context.Logger.BeginScope(sheetRow.Id))
{
if (sheetRowProperties == null)
{
sheetRowProperties = sheetRow.GetType()
.GetProperties(bindingFlags)
.Where(ShouldExport)
.OrderByDescending(x => x.Name == nameof(ISheetRow.Id))
.ToArray();
for (int i = 0; i < sheetRowProperties.Length; ++i)
{
var prop = sheetRowProperties[i];
page.SetCell(i, 0, prop.Name);
}
}
for (int i = 0; i < sheetRowProperties.Length; ++i)
{
var prop = sheetRowProperties[i];
var value = prop.GetValue(sheetRow);
var cellValue = exporter.ValueToString(prop.PropertyType, value);
page.SetCell(i, pageRow, cellValue);
}
if (sheetRow is ISheetRowArray sheetRowArray)
{
foreach (ISheetRowElem sheetElem in sheetRowArray.Arr)
{
using (context.Logger.BeginScope(sheetElem.Index))
{
if (sheetElemProperties == null)
{
sheetElemProperties = sheetElem.GetType()
.GetProperties(bindingFlags)
.Where(ShouldExport)
.ToArray();
for (int i = 0; i < sheetElemProperties.Length; ++i)
{
var prop = sheetElemProperties[i];
page.SetCell(sheetRowProperties.Length + i, 0, prop.Name);
}
}
for (int i = 0; i < sheetElemProperties.Length; ++i)
{
var prop = sheetElemProperties[i];
var value = prop.GetValue(sheetElem);
var cellValue = exporter.ValueToString(prop.PropertyType, value);
page.SetCell(sheetRowProperties.Length + i, pageRow, cellValue);
}
pageRow += 1;
}
}
}
else
{
pageRow += 1;
}
}
}
}