private void ParseDimensions(Dictionary <string, object> dimensionsJson)
{
foreach (KeyValuePair <string, object> systemKeyValuePair in dimensionsJson)
{
var dimensionJson = (Dictionary <string, object>)systemKeyValuePair.Value;
var dimension = new DimensionDefinition {
Key = systemKeyValuePair.Key,
Name = Parse <string>(dimensionJson, "name"),
Symbol = Parse <string>(dimensionJson, "symbol"),
DerivedString = Parse <string>(dimensionJson, "derived"),
BaseUnitName = Parse <string>(dimensionJson, "baseUnit"),
Vector = Parse <bool>(dimensionJson, "vector"),
IsDimensionless = Parse <bool>(dimensionJson, "dimensionless"),
InheritedUnits = Parse <string>(dimensionJson, "inheritedUnits")
};
dimension.OtherNames.AddRange(ParseArray <string>(dimensionJson, "otherNames"));
dimension.OtherSymbols.AddRange(ParseArray <string>(dimensionJson, "otherSymbols"));
ParseUnits(dimensionJson, dimension);
MeasurementCorpus.Dimensions.Add(dimension);
}
MeasurementCorpus.Dimensions.ForEach(s => s.UpdateDerived());
List <DimensionDefinition> inheritingDims = MeasurementCorpus.Dimensions.Where(d => !string.IsNullOrWhiteSpace(d.InheritedUnits)).ToList();
inheritingDims.ForEach(a => a.Units.AddRange(MeasurementCorpus.Dimensions.First(d => d.Key == a.InheritedUnits).Units));
inheritingDims.ForEach(a => a.Units.ForEach(u => u.InheritedDimensionDefinitions.Add(a)));
inheritingDims.ForEach(a => a.BaseUnit = a.Units.First(u => u.Key == a.BaseUnitName));
}
public void TestDimensionComparer()
{
var def1 = new DimensionDefinition {
Key = "test1"
};
var def2 = new DimensionDefinition {
Key = "test1"
};
Assert.AreEqual(0, DimensionDefinitionComparer.Comparer.Compare(null, null));
Assert.AreEqual(1, DimensionDefinitionComparer.Comparer.Compare(def1, null));
Assert.AreEqual(-1, DimensionDefinitionComparer.Comparer.Compare(null, def2));
Assert.AreEqual(0, DimensionDefinitionComparer.Comparer.Compare(def1, def2));
def2.Key = "test0";
Assert.AreEqual(-1, DimensionDefinitionComparer.Comparer.Compare(def1, def2));
def2.Key = "test1";
def1.IsDimensionless = true;
Assert.AreEqual(-1, DimensionDefinitionComparer.Comparer.Compare(def1, def2));
def2.IsDimensionless = true;
Assert.AreEqual(0, DimensionDefinitionComparer.Comparer.Compare(def1, def2));
def1.Vector = true;
Assert.AreEqual(-1, DimensionDefinitionComparer.Comparer.Compare(def1, def2));
def2.Vector = true;
Assert.AreEqual(0, DimensionDefinitionComparer.Comparer.Compare(def1, def2));
def2.DerivedString = "temperature";
def2.UpdateDerived();
Assert.AreEqual(1, DimensionDefinitionComparer.Comparer.Compare(def1, def2));
def1.DerivedString = "time*time";
def1.UpdateDerived();
Assert.AreEqual(0, DimensionDefinitionComparer.Comparer.Compare(def1, def2));
}
private void ParseUnits(Dictionary <string, object> dimensionJson, DimensionDefinition dimension)
{
foreach (KeyValuePair <string, object> unitKeyValuePair in (Dictionary <string, object>)dimensionJson["units"])
{
var unitJson = (Dictionary <string, object>)unitKeyValuePair.Value;
var unit = new Unit {
Key = unitKeyValuePair.Key,
Name = Parse <string>(unitJson, "name"),
Plural = Parse <string>(unitJson, "plural"),
DimensionDefinition = dimension,
Type = Parse <UnitType>(unitJson, "type"),
Symbol = Parse <string>(unitJson, "symbol"),
Multiplier = Parse <double>(unitJson, "multiplier"),
Offset = Parse <double>(unitJson, "offset"),
IsRare = Parse <bool>(unitJson, "rare"),
IsEstimation = Parse <bool>(unitJson, "estimation"),
PrefixName = Parse <string>(unitJson, "prefixName"),
PrefixFreeName = Parse <string>(unitJson, "prefixFreeName")
};
unit.MeasurementSystemNames.AddRange(ParseArray <string>(unitJson, "systems"));
unit.OtherNames.AddRange(ParseArray <string>(unitJson, "otherNames"));
unit.OtherSymbols.AddRange(ParseArray <string>(unitJson, "otherSymbols"));
unit.UpdateMeasurementSystems();
dimension.Units.Add(unit);
if (dimension.BaseUnitName == unit.Key)
{
dimension.BaseUnit = unit;
}
}
}
public static bool DimensionFilter(DimensionDefinition arg)
{
if (!Options.AllowVectorDimensions && arg.Vector)
{
return(false);
}
if (!Options.AllowDerivedDimensions && arg.IsDerived())
{
return(false);
}
if (Options.IgnoredDimensions.Contains(arg))
{
return(false);
}
return(true);
}
public void TestDimensionFilter()
{
var def = new DimensionDefinition {
Key = "test"
};
Assert.IsTrue(MeasurementCorpus.DimensionFilter(def));
def.Vector = true;
Assert.IsFalse(MeasurementCorpus.DimensionFilter(def));
MeasurementCorpus.Options.AllowVectorDimensions = true;
Assert.IsTrue(MeasurementCorpus.DimensionFilter(def));
def.DerivedString = "temperature/time";
def.UpdateDerived();
Assert.IsTrue(MeasurementCorpus.DimensionFilter(def));
MeasurementCorpus.Options.AllowDerivedDimensions = false;
Assert.IsFalse(MeasurementCorpus.DimensionFilter(def));
MeasurementCorpus.Options.AllowDerivedDimensions = true;
Assert.IsTrue(MeasurementCorpus.DimensionFilter(def));
MeasurementCorpus.Options.IgnoredDimensions.Add(def);
Assert.IsFalse(MeasurementCorpus.DimensionFilter(def));
}
// Creates color scheme entries used to map dimension values, measures and colors.
private ColorSchemeEntry CreateColorSchemeEntry(DataRow colorSchemeRecord,
IDashboardDataSource dataSource,
bool includeMeasures)
{
DimensionDefinition categoryDefinition = new DimensionDefinition("CategoryName");
DimensionDefinition countryDefinition = new DimensionDefinition("Country");
MeasureDefinition priceDefinition = new MeasureDefinition("Extended Price");
ColorSchemeEntry entry = new ColorSchemeEntry();
entry.DimensionKeys.Add(new ColorSchemeDimensionKey(categoryDefinition,
colorSchemeRecord["CategoryName"]));
entry.DimensionKeys.Add(new ColorSchemeDimensionKey(countryDefinition,
colorSchemeRecord["Country"]));
if (includeMeasures)
{
entry.MeasureKey = new ColorSchemeMeasureKey(priceDefinition);
}
entry.ColorDefinition = new ColorDefinition((Color)colorSchemeRecord["color"]);
entry.DataSource = dataSource;
return(entry);
}
public static Population <Chromosome, BinaryRepresentation> GeneratePopulation(
int populationSize,
Domain domain,
DimensionDefinition dimensionDefinition,
int precision)
{
if (populationSize <= 0)
{
throw new InvalidOperationException("Population size should be greater than 0!");
}
var population = new List <Chromosome>();
for (var size = 1; size <= populationSize; size++)
{
var chromosomeComponents =
DomainHelper.RandomDimensionalBinaryValueInDomainRange(domain, dimensionDefinition, precision);
var chromosome = Chromosome.Create(chromosomeComponents);
population.Add(chromosome);
}
return(Population <Chromosome, BinaryRepresentation> .Create(population));
}
protected override void Seed(NeuCMS.Repositories.EntityFramework.ContentRepository context)
{
var nameSpace = new NameSpace()
{
Id = 1,
Description = "Sample NeuCMS Content Data",
NameSpaceName = "NeuCMS.Samples"
};
context.NameSpaces.AddOrUpdate(
n => n.Id,
nameSpace);
var contentDef1 = new ContentDefinition()
{
Id = 1,
Name = "Message",
NameSpace = nameSpace,
AvailableOnAllViews = false
};
var contentDef2 = new ContentDefinition()
{
Id = 2,
Name = "Image",
NameSpace = nameSpace,
AvailableOnAllViews = false
};
var view = new View()
{
Id = 1,
NameSpace = nameSpace,
ViewName = "Home",
ContentDefinitions = new List <ContentDefinition>()
{
contentDef1,
contentDef2
}
};
var dimDef = new DimensionDefinition()
{
Id = 1, DimensionName = "Language", NameSpace = nameSpace
};
var elementContent = new ElementContent()
{
Id = 1,
Content = "Hello World!",
ContentElementDefinition = view.ContentDefinitions[0],
Dimensions = new List <DimensionValue>()
{
new DimensionValue()
{
Id = 1,
DimensionDefinition = dimDef,
Value = "English"
}
}
};
var converter = new ImageConverter();
var imgBytes = (byte[])converter.ConvertTo(TestData.Test, typeof(byte[]));
var mediaContent = new MediaContent()
{
Id = 2,
ContentElementDefinition = view.ContentDefinitions[1],
Dimensions = new List <DimensionValue>()
{
new DimensionValue()
{
Id = 1,
DimensionDefinition = dimDef,
Value = "English"
}
},
DigitalAsset = new DigitalAsset()
{
Id = 1,
ContentType = "image/jpeg",
Data = imgBytes
}
};
context.Views.AddOrUpdate(v => v.Id, view);
context.ContentDefinitions.AddOrUpdate(c => c.Name, contentDef1);
context.DimensionDefinitions.AddOrUpdate(d => d.DimensionName, dimDef);
context.Contents.AddOrUpdate(c => c.Id, elementContent);
context.Contents.AddOrUpdate(c => c.Id, mediaContent);
}
internal static RepositorySchema LoadSchemaForType(Type dsType, bool inheritedFieldList = false)
{
if (dsType == null)
{
throw new Exception("The type must be set");
}
if (!dsType.GetInterfaces().Any(x => x.Name == typeof(IDatastoreItem).Name))
{
throw new Exception($"The item must implement {typeof(IDatastoreItem).Name}.");
}
var dsRepositoryAttribute = dsType.GetCustomAttributes().FirstOrDefault(x => x is DatastoreRepositoryAttribute) as DatastoreRepositoryAttribute;
if (dsRepositoryAttribute == null)
{
throw new InvalidOperationException("Cannot create repository for the specified type. Missing DataStoreRepositoryAttribute.");
}
var schema = new RepositorySchema();
schema.Name = dsRepositoryAttribute.Name;
schema.ObjectAlias = dsRepositoryAttribute.ObjectAlias;
Guid rid;
Guid.TryParse(dsRepositoryAttribute.Id, out rid);
if (rid == Guid.Empty)
{
rid = Guid.NewGuid();
}
schema.ID = rid;
if (!string.IsNullOrEmpty(dsRepositoryAttribute.ParentId))
{
schema.ParentID = new Guid(dsRepositoryAttribute.ParentId);
}
schema.FieldIndexing = dsRepositoryAttribute.FieldIndexing;
//var properties = GetTemplateFields(dsType);
var properties = new List <MemberInfo>();
properties.AddRange(dsType.GetProperties());
properties.AddRange(dsType.GetFields());
#region Loop Fields
foreach (MemberInfo prop in properties)
{
var field = prop.CustomAttributes.FirstOrDefault(x => x.AttributeType == typeof(DatastoreFieldAttribute)) as CustomAttributeData;
if (field != null)
{
var isNullable = false;
var fieldDefition = default(FieldDefinition);
var defFieldType = RepositorySchema.DataTypeConstants.String;
var defLength = 100;
var propertyTypeName = "";
if (prop is PropertyInfo)
{
propertyTypeName = ((PropertyInfo)prop).PropertyType.Name;
if (propertyTypeName.Contains("Nullable"))
{
isNullable = true;
propertyTypeName = ((PropertyInfo)prop).PropertyType.GenericTypeArguments.Select(x => x.Name).FirstOrDefault();
}
}
else if (prop is FieldInfo)
{
propertyTypeName = ((FieldInfo)prop).FieldType.Name;
if (propertyTypeName.Contains("Nullable"))
{
isNullable = true;
propertyTypeName = ((FieldInfo)prop).FieldType.GenericTypeArguments.Select(x => x.Name).FirstOrDefault();
}
}
switch (propertyTypeName)
{
case "String[]":
defFieldType = RepositorySchema.DataTypeConstants.List;
isNullable = true;
break;
case "String":
defFieldType = RepositorySchema.DataTypeConstants.String;
isNullable = true;
break;
case "Int16":
case "Int32":
case "UInt32":
case "Byte":
defFieldType = RepositorySchema.DataTypeConstants.Int;
break;
case "Int64":
defFieldType = RepositorySchema.DataTypeConstants.Int64;
break;
case "Bool":
case "Boolean":
defFieldType = RepositorySchema.DataTypeConstants.Bool;
break;
case "DateTime":
defFieldType = RepositorySchema.DataTypeConstants.DateTime;
break;
case "Double":
case "Single":
case "Decimal":
defFieldType = RepositorySchema.DataTypeConstants.Float;
break;
case "Char":
defFieldType = RepositorySchema.DataTypeConstants.String;
defLength = 1;
break;
case "GeoCode":
defFieldType = RepositorySchema.DataTypeConstants.GeoCode;
isNullable = true;
break;
default:
break;
}
var name = GetAttributeValue <string>(field, "Name", prop.Name);
var dataType = GetAttributeValue <RepositorySchema.DataTypeConstants>(field, "DataType", defFieldType);
var fieldType = GetAttributeValue <RepositorySchema.FieldTypeConstants>(field, "FieldType", RepositorySchema.FieldTypeConstants.Field);
var isPrimaryKey = GetAttributeValue <bool>(field, "IsPrimaryKey", false);
var isDataGrouping = GetAttributeValue <bool>(field, "IsDataGrouping", false);
var length = GetAttributeValue <int>(field, "Length", defLength);
var allowTextSearch = GetAttributeValue <bool>(field, "AllowTextSearch", false);
var isPivot = GetAttributeValue <bool>(field, "IsPivot", false);
var pivotGroup = GetAttributeValue <string>(field, "PivotGroup", String.Empty);
var pivotOrder = GetAttributeValue <int>(field, "PivotOrder", 0);
var description = GetAttributeValue <string>(field, "Description", String.Empty);
var searchAsc = GetAttributeValue <bool>(field, "SearchAsc", true);
var allowIndex = GetAttributeValue <bool>(field, "AllowIndex", true);
if (fieldType == RepositorySchema.FieldTypeConstants.Dimension)
{
fieldDefition = new DimensionDefinition();
}
else
{
fieldDefition = new FieldDefinition();
}
fieldDefition.Name = name;
fieldDefition.DataType = dataType;
fieldDefition.FieldType = fieldType;
fieldDefition.IsPrimaryKey = isPrimaryKey;
fieldDefition.IsDataGrouping = isDataGrouping;
fieldDefition.AllowNull = isNullable;
fieldDefition.Length = length;
fieldDefition.AllowTextSearch = allowTextSearch;
fieldDefition.Name = name;
fieldDefition.IsPivot = isPivot;
fieldDefition.PivotGroup = pivotGroup;
fieldDefition.PivotOrder = pivotOrder;
fieldDefition.Description = description;
fieldDefition.SearchAsc = searchAsc;
fieldDefition.AllowIndex = allowIndex;
//If PK and nullable then error
if (isPrimaryKey && isNullable)
{
throw new Exception("The primary key cannot be nullable.");
}
if (isPrimaryKey && !allowIndex)
{
throw new Exception("The primary key must be indexed.");
}
//Default to unlimited string length
if (defFieldType == RepositorySchema.DataTypeConstants.String && defLength < 0)
{
defLength = 0;
}
if (fieldType == RepositorySchema.FieldTypeConstants.Dimension)
{
switch (defFieldType)
{
case RepositorySchema.DataTypeConstants.Bool:
case RepositorySchema.DataTypeConstants.String:
case RepositorySchema.DataTypeConstants.List:
case RepositorySchema.DataTypeConstants.Int:
case RepositorySchema.DataTypeConstants.Int64:
case RepositorySchema.DataTypeConstants.DateTime:
break;
default:
throw new Exception($"Field '{name}': The data type '{defFieldType}' cannot be a dimension.");
}
}
if (fieldType == RepositorySchema.FieldTypeConstants.Dimension)
{
var dimension = fieldDefition as DimensionDefinition;
if (dimension == null)
{
throw new Exception("Dimension is null");
}
var didx = GetAttributeValue <int?>(field, "Didx", null);
if (didx.HasValue)
{
dimension.DIdx = didx.Value;
}
dimension.Parent = GetAttributeValue <string>(field, "Parent", String.Empty);
dimension.DimensionType = GetAttributeValue <RepositorySchema.DimensionTypeConstants>(field, "DimensionType", RepositorySchema.DimensionTypeConstants.Normal);
var numericBreak = GetAttributeValue <long?>(field, "NumericBreak", null);
if ((dimension.DataType == RepositorySchema.DataTypeConstants.Int || dimension.DataType == RepositorySchema.DataTypeConstants.Int64) && numericBreak.HasValue)
{
dimension.NumericBreak = numericBreak.Value;
}
else if (numericBreak.HasValue)
{
throw new Exception("Numeric breaks are only applicable for Integer fields.");
}
//If the datatype is list then the DimensionType must be list
if (dimension.DataType == RepositorySchema.DataTypeConstants.List)
{
dimension.DimensionType = RepositorySchema.DimensionTypeConstants.List;
}
}
if (GetAttributeValue <bool>(field, "UserPermission", false))
{
schema.UserPermissionField = fieldDefition;
}
schema.FieldList.Add(fieldDefition);
}
}
#endregion
var hasGeo = schema.FieldList.Any(x => x.DataType == RepositorySchema.DataTypeConstants.GeoCode);
var hasGroupingData = (schema.FieldList.Where(x => x.IsDataGrouping).Count() > 1);
if (schema.FieldList.Count == 0)
{
throw new Exception("The item must have fields defined.");
}
if (schema.FieldList.Count(x => x.IsPrimaryKey) != 1)
{
throw new Exception("The item must have exactly one primary key defined.");
}
if (schema.FieldList.Count != schema.FieldList.Select(x => x.Name.ToLower()).Distinct().Count())
{
throw new Exception("The item cannot have duplicate fields.");
}
if (schema.FieldList.Where(x => x.IsDataGrouping).Count() > 1)
{
throw new Exception("The item cannot have more than one data group field.");
}
if (hasGeo && hasGroupingData)
{
throw new Exception("The item cannot have a data grouping and GeoCode field.");
}
//This is a child so remove parent fields from schema
if (schema.ParentID != null && !inheritedFieldList)
{
if (!dsType.BaseType.GetInterfaces().Any(x => x.Name == typeof(IDatastoreItem).Name))
{
throw new Exception($"The item base must implement {typeof(IDatastoreItem).Name}.");
}
var parentSchema = LoadSchemaForType(dsType.BaseType);
schema = schema.Subtract(parentSchema);
}
foreach (var ditem in schema.DimensionList.Where(x => !string.IsNullOrEmpty(x.Parent)).ToList())
{
//Verify that no parent dimension is self-referential
if (ditem.Parent.Match(ditem.Name))
{
throw new Exception($"The dimension '{ditem.Name}' cannot be its own parent.");
}
//Error check that parent dimension actually exists
if (!schema.DimensionList.Any(x => x.Name == ditem.Parent))
{
throw new Exception($"The dimension '{ditem.Name}' defines a non-existent parent.");
}
}
//TODO: Verify that no parent dimensions cause a cycle (A->B->A)
return(schema);
}
private static List <Unit> FindUnitsImpl(List <Unit> existingMatches, string unitName, DimensionDefinition dimension, bool ignoreCase,
Matcher <Unit> matcher, ListMatcher <Unit> listMatcher)
{
if (string.IsNullOrWhiteSpace(unitName))
{
throw new ArgumentException("unitName must be a string at least one character of non-whitespace");
}
List <Unit> allUnits = (dimension == null) ? AllUnits : dimension.Units;
return(existingMatches
.Union(matcher(allUnits, unitName, u => u.Key, ignoreCase))
.Union(matcher(allUnits, unitName, u => u.Name, ignoreCase))
.Union(matcher(allUnits, unitName, u => u.Plural, ignoreCase))
.Union(matcher(allUnits, unitName, u => u.Symbol, ignoreCase))
.Union(listMatcher(allUnits, unitName, u => u.OtherNames, ignoreCase))
.Union(listMatcher(allUnits, unitName, u => u.OtherSymbols, ignoreCase))
.Where(UnitFilter)
.OrderByDescending(x => x, UnitComparer.Comparer).ToList());
}
public static List <Unit> FindUnitsPartial(string unitName, DimensionDefinition dimension = null, bool ignoreCase = true)
{
return(FindUnitsImpl(FindUnits(unitName, dimension, ignoreCase), unitName, dimension, ignoreCase, PartialMatches, PartialListMatches));
}
public static List <Unit> FindUnits(string unitName, DimensionDefinition dimension = null, bool ignoreCase = true)
{
return(FindUnitsImpl(new List <Unit>(), unitName, dimension, ignoreCase, Matches, ListMatches));
}
public static Unit FindUnitPartial(string unitName, DimensionDefinition dimension = null, bool ignoreCase = true)
{
return(FindUnitsPartial(unitName, dimension, ignoreCase).FirstOrDefault());
}
public static Unit FindBaseUnitPartial(string dimensionName, bool ignoreCase = true)
{
DimensionDefinition dimension = FindDimensionPartial(dimensionName, ignoreCase);
return((dimension != null) ? dimension.BaseUnit : null);
}
