public ReferenceContext(TableStore store, ClassMapping cMapping)
{
Store = store;
CMapping = cMapping;
Children = new List <ReferenceContext>();
ContextType = ReferenceContextType.Root;
PathTypeHint = Store.MetaData.ExpressType(cMapping.Class.ToUpper());
if (cMapping.PropertyMappings == null || !cMapping.PropertyMappings.Any())
{
return;
}
var parentPath = ("parent." + cMapping.ParentPath).Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries).ToList();
foreach (var mapping in cMapping.PropertyMappings)
{
var path = mapping.Paths.FirstOrDefault();
if (string.IsNullOrWhiteSpace(path))
{
continue;
}
var segments = path.Split('.').ToList();
//if path uses upper context of parent, fix the path to be relative to parent
if (path[0] == '(')
{
var levelCount = path.Count(c => c == '(');
segments =
parentPath.GetRange(0, parentPath.Count - levelCount)
.Concat(segments.GetRange(levelCount, segments.Count - levelCount))
.ToList();
}
AddMapping(mapping, segments);
}
//add special mapping for a parent path
if (!cMapping.IsRoot)
{
var pMap = new PropertyMapping {
_Paths = string.Join(".", parentPath), Status = DataStatus.Reference
};
AddMapping(pMap, parentPath);
}
}
private void AddMapping(PropertyMapping pMapping, List <string> segments)
{
if (segments == null || !segments.Any())
{
//this is a leaf
Mapping = pMapping;
return;
}
var segment = segments.First();
var segmentName = segment.Split('\\')[0];
//handle special cases - type hints
switch (segment)
{
case "[table]":
TableHintMapping = pMapping;
return;
case "[type]":
TypeHintMapping = pMapping;
return;
}
var existChild = Children.FirstOrDefault(c => c.Segment == segmentName);
if (existChild != null)
{
existChild.AddMapping(pMapping, segments.GetRange(1, segments.Count - 1));
}
else
{
var child = new ReferenceContext(segment, this, Store, CMapping);
child.AddMapping(pMapping, segments.GetRange(1, segments.Count - 1));
Children.Add(child);
//cache scalar children for optimization
if (child.ContextType == ReferenceContextType.Scalar || child.ContextType == ReferenceContextType.ScalarList)
{
_scalarChildren.Add(child);
}
}
}
private void Store(IRow row, object value, PropertyMapping mapping)
{
if (value == null)
{
return;
}
var cellIndex = CellReference.ConvertColStringToIndex(mapping.Column);
var cell = row.GetCell(cellIndex) ?? row.CreateCell(cellIndex);
//set column style to cell
cell.CellStyle = row.Sheet.GetColumnStyle(cellIndex);
//simplify any eventual enumeration into a single string
var enumVal = value as IEnumerable;
if (enumVal != null && !(value is string))
{
var strValue = string.Join(Mapping.ListSeparator, enumVal.Cast <object>());
cell.SetCellType(CellType.String);
cell.SetCellValue(strValue);
return;
}
//string value
var str = value as string;
if (str != null)
{
cell.SetCellType(CellType.String);
cell.SetCellValue(str);
return;
}
//numeric point types
if (value is double || value is float || value is int || value is long || value is short || value is byte || value is uint || value is ulong ||
value is ushort)
{
cell.SetCellType(CellType.Numeric);
cell.SetCellValue(Convert.ToDouble(value));
return;
}
//boolean value
if (value is bool)
{
cell.SetCellType(CellType.Boolean);
cell.SetCellValue((bool)value);
return;
}
//enumeration
if (value is Enum)
{
var eType = value.GetType();
var eValue = Enum.GetName(eType, value);
cell.SetCellType(CellType.String);
//try to get alias from configuration
var alias = GetEnumAlias(eType, eValue);
cell.SetCellValue(alias ?? eValue);
return;
}
throw new NotSupportedException("Only base types are supported");
}
private void Store(ISheet sheet, IPersistEntity entity, ClassMapping mapping, ExpressType expType, EntityContext context)
{
var multiRow = -1;
List <string> multiValues = null;
PropertyMapping multiMapping = null;
var row = GetRow(sheet);
//fix on "Special Case" Assembly Row to Entity mapping
if ((context?.RootEntity != null) && (expType?.ExpressNameUpper == "TYPEORCOMPONENT")) //without CobieExpress reference and not using reflection this is as good as it gets to ID Assembly
{
RowNoToEntityLabelLookup[sheet.SheetName].Add(row.RowNum, context.RootEntity.EntityLabel);
}
else
{
RowNoToEntityLabelLookup[sheet.SheetName].Add(row.RowNum, entity.EntityLabel);
}
foreach (var propertyMapping in mapping.PropertyMappings)
{
object value = null;
foreach (var path in propertyMapping.Paths)
{
value = GetValue(entity, expType, path, context);
if (value != null)
{
break;
}
}
if (value == null && propertyMapping.Status == DataStatus.Required)
{
value = propertyMapping.DefaultValue ?? "n/a";
}
var isMultiRow = IsMultiRow(value, propertyMapping);
if (isMultiRow)
{
multiRow = row.RowNum;
var values = new List <string>();
var enumerable = value as IEnumerable <string>;
if (enumerable != null)
{
values.AddRange(enumerable);
}
//get only first value and store it
var first = values.First();
Store(row, first, propertyMapping);
//set the rest for the processing as multiValue
values.Remove(first);
multiValues = values;
multiMapping = propertyMapping;
}
else
{
Store(row, value, propertyMapping);
}
}
//adjust width of the columns after the first and the eight row
//adjusting fully populated workbook takes ages. This should be almost all right
if (row.RowNum == 1 || row.RowNum == 8)
{
AdjustAllColumns(sheet, mapping);
}
//it is not a multi row so return
if (multiRow <= 0 || multiValues == null || !multiValues.Any())
{
return;
}
//add repeated rows if necessary
foreach (var value in multiValues)
{
var rowNum = GetNextRowNum(sheet);
var copy = sheet.CopyRow(multiRow, rowNum);
Store(copy, value, multiMapping);
RowNoToEntityLabelLookup[sheet.SheetName].Add(rowNum, entity.EntityLabel);
}
}