public void ValidateTypeMapping(TypeMapping mapping)
{
var usingMultimapping = mappingBehaviors.HasFlag(MappingBehaviors.MultimapByDefault) || configurationDetails.IsMultimap(mapping.From);
if (!usingMultimapping)
CheckForExistingTypeMapping(target, mapping);
CheckForExistingNamedMapping(target, mapping, configurationDetails);
}
private IMethodDefinition FindBestMatch(IMethodDefinition matchMethod, TypeMapping mapping, int typeIndex, int memberIndex)
{
// No matches if we don't have a matching type.
if (mapping[typeIndex] == null)
return null;
foreach (IMethodDefinition method in mapping[typeIndex].Methods)
{
if (method.Name.Value != matchMethod.Name.Value) continue;
if (method.ParameterCount != matchMethod.ParameterCount) continue;
if (method.IsGeneric && matchMethod.IsGeneric &&
method.GenericParameterCount != matchMethod.GenericParameterCount)
continue;
MemberMapping member = mapping.FindMember(method);
// It is possible to find a match that was filtered at the mapping layer
if (member == null) continue;
// If the other member also doesn't have a match then this is our best match
if (member[memberIndex] == null)
return method;
}
return null;
}
public String GetRegistrationName(TypeMapping typeMapping)
{
var namedMappingRequested = configurationDetails.IsMultimap(typeMapping.From) || configurationDetails.IsNamedMapping(typeMapping.To);
var namedMappingRequired = mappingBehaviors.HasFlag(MappingBehaviors.MultimapByDefault) && multimapTypes.Contains(typeMapping.From);
return (namedMappingRequested || namedMappingRequired) ? configurationDetails.GetNamedMapping(typeMapping)
: null;
}
private static void CheckForExistingTypeMapping(IUnityContainer target, TypeMapping mapping)
{
var existingRegistration = target.Registrations
.FirstOrDefault(r => r.RegisteredType.Equals(mapping.From));
if (existingRegistration != null)
throw new DuplicateMappingException(mapping.From, existingRegistration.MappedToType, mapping.To);
}
public MMElement(TypeMapping typeMapping, object value, IElement container = null)
{
if (typeMapping == null) throw new ArgumentNullException(nameof(typeMapping));
_typeMapping = typeMapping;
_instance = value;
_container = container;
}
/// <summary>
/// Adds the given <paramref name="mapping"/> to <see cref="Mappings"/>.
/// </summary>
/// <param name="mapping">The <see cref="TypeMapping"/> which to add.</param>
/// <exception cref="ArgumentNullException">Thrown if one of the parameters is null.</exception>
public void Add(TypeMapping mapping)
{
// validate arguments
if (mapping == null)
throw new ArgumentNullException("mapping");
// add the mapping
Mappings.Add(mapping.Name, mapping);
}
public InjectionMember[] CreateInjectionMembers(TypeMapping typeMapping)
{
var requiresPolicyInjection = configurationDetails.IsMarkedForPolicyInjection(typeMapping.From)
|| TypeHasHandlerAttribute(typeMapping.From)
|| TypeHasHandlerAttribute(typeMapping.To);
return requiresPolicyInjection ? new InjectionMember[] { new Interceptor<InterfaceInterceptor>(), new InterceptionBehavior<PolicyInjectionBehavior>() }
: new InjectionMember[0];
}
private static void CheckForExistingNamedMapping(IUnityContainer target, TypeMapping mapping, AutomapperConfig configurationDetails)
{
var mappingName = configurationDetails.GetNamedMapping(mapping);
var existingRegistration = target.Registrations
.Where(r => String.Equals(r.Name, mappingName))
.Where(r => r.RegisteredType.Equals(mapping.From))
.FirstOrDefault();
if (existingRegistration != null)
throw new DuplicateMappingException(mapping.From, existingRegistration.MappedToType, mapping.To, mappingName);
}
public bool Include(TypeMapping type)
{
var isAdded = type.Difference == DifferenceType.Added;
var isRemoved = type.Difference == DifferenceType.Removed;
var onBothSides = !isAdded && !isRemoved;
var include = onBothSides ||
isAdded && _includeAddedTypes ||
isRemoved && _includeRemovedTypes;
return _baseFilter.Include(type) && include;
}
public void TestMMObjects()
{
var typeMapper = new TypeMapping();
typeMapper.CreateNewObject = () => new MapTestClass();
typeMapper.GetId = (x) => (x as MapTestClass).Id.ToString();
typeMapper.AddProperty(
MapTestClass.IdProperty,
(x) => (x as MapTestClass).Id,
(x, v) => (x as MapTestClass).Id = v);
typeMapper.AddProperty(
MapTestClass.NameProperty,
(x) => (x as MapTestClass).Name,
(x, v) => (x as MapTestClass).Name = v);
}
public void Predicate_ForInterface_CanBuildPredicate()
{
var mapping = new TypeMapping<IPerson, Person>();
var expression = mapping.Predicate("p => p.LastName == \"LName\"").Compile();
var persons = new List<IPerson>
{
new Person{ Id = 1, LastName = "LName"},
new Person{ Id = 2, LastName = "LName2"},
};
var filteredPersons = persons.Where(expression).ToList();
Assert.AreEqual(1, filteredPersons.Count);
Assert.AreEqual(1, filteredPersons[0].Id);
}
public void CreateIndexMultiFieldMap()
{
var client = this.ConnectedClient;
var typeMapping = new TypeMapping(Guid.NewGuid().ToString("n"));
var property = new TypeMappingProperty
{
Type = "multi_field"
};
var primaryField = new TypeMappingProperty
{
Type = "string",
Index = "not_analyzed"
};
var analyzedField = new TypeMappingProperty
{
Type = "string",
Index = "analyzed"
};
property.Fields = new Dictionary<string, TypeMappingProperty>();
property.Fields.Add("name", primaryField);
property.Fields.Add("name_analyzed", analyzedField);
typeMapping.Properties.Add("name", property);
var settings = new IndexSettings();
settings.Mappings.Add(typeMapping);
settings.NumberOfReplicas = 1;
settings.NumberOfShards = 5;
settings.Analysis.Analyzer.Add("snowball", new SnowballAnalyzerSettings { Language = "English" });
var indexName = Guid.NewGuid().ToString();
var response = client.CreateIndex(indexName, settings);
Assert.IsTrue(response.IsValid);
Assert.IsTrue(response.OK);
Assert.IsNotNull(this.ConnectedClient.GetMapping(indexName, typeMapping.Name));
response = client.DeleteIndex(indexName);
Assert.IsTrue(response.IsValid);
Assert.IsTrue(response.OK);
}
public static APPSettModel ConvertGoodsInSql(AppModel model)
{
if (model != null)
{
var r = new APPSettModel();
//映射处理
var map = new TypeMapping<AppModel, APPSettModel>();
map.AutoMap();
map.CopyLeftToRight(model, r);
//r.TaxonomyId = r.Categorys.Union(r.Tags).Distinct().Select(e => e.Key).ToList();
return r;
}
return null;
}
public void Predicate_WithMultiStatementSetup_LF_ForInterface_CanBuildPredicate()
{
var mapping = new TypeMapping<IPerson, Person>();
var setupStatement = "using System;\n var date = DateTime.Parse(\"1987-03-01\");";
var expression = mapping.Predicate("p => p.Birthdate == date", setupStatement).Compile();
var persons = new List<IPerson>
{
new Person{ Id = 1, Birthdate = DateTime.Parse("1987-03-01") },
new Person{ Id = 2, Birthdate = DateTime.Parse("1987-03-02") },
};
var filteredPersons = persons.Where(expression).ToList();
Assert.AreEqual(1, filteredPersons.Count);
Assert.AreEqual(1, filteredPersons[0].Id);
}
public static ShopInSql ConvertShopInSql(ShopDetail model)
{
if (model != null)
{
var r = new ShopInSql();
//映射处理
var map = new TypeMapping<ShopDetail, ShopInSql>();
map.AutoMap();
map.CopyLeftToRight(model, r);
r.AreaId = r.Areas.Select(e => e.Key).ToList();
return r;
}
return null;
}
public virtual bool Include(TypeMapping type)
{
bool anyIncluded = false;
for (int i = 0; i < type.ElementCount; i++)
if (type[i] != null && _filter.Include(type[i]))
anyIncluded = true;
if (!anyIncluded)
return false;
if (Include(type.Difference))
return true;
if (type.ShouldDiffMembers)
return type.Members.Any(Include);
return false;
}
public static ArchiveInSql ConvertArchiveInSql(ArticleDetail model)
{
if (model != null)
{
var r = new ArchiveInSql();
//映射处理
var map = new TypeMapping<ArticleDetail, ArchiveInSql>();
map.AutoMap();
map.CopyLeftToRight(model, r);
r.TaxonomyId = r.Categorys.Union(r.Tags).Distinct().Select(e => e.Key).ToList();
return r;
}
return null;
}
/// <summary>
/// Adds <see cref="PropertyMapping"/>s of <paramref name="property"/> to the given <paramref name="typeMapping"/>.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="property">The <see cref="IPropertyDefinition"/> of the property for which to add the <see cref="PropertyMapping"/>s.</param>
/// <param name="typeMapping">The <see cref="TypeMapping"/> to which to add the new <see cref="PropertyMapping"/>s.</param>
protected override void DoAddMappingTo(IMansionContext context, IPropertyDefinition property, TypeMapping typeMapping)
{
typeMapping.Add(new SingleValuedPropertyMapping("approved")
{
Type = "boolean"
});
typeMapping.Add(new SingleValuedPropertyMapping("archived")
{
Type = "boolean"
});
typeMapping.Add(new SingleValuedPropertyMapping("publicationDate")
{
Type = "date"
});
typeMapping.Add(new SingleValuedPropertyMapping("expirationDate")
{
Type = "date"
});
}
public static GoodsDetailInSql ConvertGoodsInSql(GoodsDetail model)
{
if (model != null)
{
var r = new GoodsDetailInSql();
//映射处理
var map = new TypeMapping<GoodsDetail, GoodsDetailInSql>();
map.AutoMap();
map.CopyLeftToRight(model, r);
r.CategoryId = r.ItemShopCats.Select(e => e.Id).ToList();
//r.TaxonomyId = r.Categorys.Union(r.Tags).Distinct().Select(e => e.Key).ToList();
return r;
}
return null;
}
private void Print(object value, ExpressionPrinter expressionPrinter) => expressionPrinter.Append(TypeMapping?.GenerateSqlLiteral(value) ?? Value?.ToString() ?? "NULL");
public void Visit(TypeMapping mapping)
{
Increment("type");
}
public static FieldSchema FromDto(FieldSchemaDto fieldSchemaDto)
{
return(new FieldSchema(fieldSchemaDto.Name, TypeMapping.FromTypeName(fieldSchemaDto.TypeName)));
}
private LVC.Model.test._InputMeta Createtest_InputMeta(TypeMapping typeMapping)
{
Dictionary <string, FieldMapping> fieldLookup = typeMapping.FieldMappings.ToDictionary(mapping => mapping.Field.Identifier);
LVC.Model.test._InputMeta obj = new LVC.Model.test._InputMeta();
{
// Assign MetaValues value to "TapVTx4" field
FieldMapping fieldMapping = fieldLookup["TapVTx4"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.TapVTx4 = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "MwVTx4" field
FieldMapping fieldMapping = fieldLookup["MwVTx4"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.MwVTx4 = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "MvrVTx4" field
FieldMapping fieldMapping = fieldLookup["MvrVTx4"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.MvrVTx4 = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "VoltsVTx4" field
FieldMapping fieldMapping = fieldLookup["VoltsVTx4"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.VoltsVTx4 = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "TapVTx5" field
FieldMapping fieldMapping = fieldLookup["TapVTx5"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.TapVTx5 = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "MwVTx5" field
FieldMapping fieldMapping = fieldLookup["MwVTx5"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.MwVTx5 = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "MvrVTx5" field
FieldMapping fieldMapping = fieldLookup["MvrVTx5"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.MvrVTx5 = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "VoltsVTx5" field
FieldMapping fieldMapping = fieldLookup["VoltsVTx5"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.VoltsVTx5 = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "BusBkrVCap1" field
FieldMapping fieldMapping = fieldLookup["BusBkrVCap1"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.BusBkrVCap1 = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "CapBkrVCap1" field
FieldMapping fieldMapping = fieldLookup["CapBkrVCap1"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.CapBkrVCap1 = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "LocKvVCap1" field
FieldMapping fieldMapping = fieldLookup["LocKvVCap1"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.LocKvVCap1 = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "BusBkrVCap2" field
FieldMapping fieldMapping = fieldLookup["BusBkrVCap2"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.BusBkrVCap2 = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "CapBkrVCap2" field
FieldMapping fieldMapping = fieldLookup["CapBkrVCap2"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.CapBkrVCap2 = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "LocKvVCap2" field
FieldMapping fieldMapping = fieldLookup["LocKvVCap2"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.LocKvVCap2 = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "G1Mw" field
FieldMapping fieldMapping = fieldLookup["G1Mw"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.G1Mw = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "G1Mvr" field
FieldMapping fieldMapping = fieldLookup["G1Mvr"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.G1Mvr = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "G2Mw" field
FieldMapping fieldMapping = fieldLookup["G2Mw"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.G2Mw = GetMetaValues(measurement);
}
{
// Assign MetaValues value to "G2Mvr" field
FieldMapping fieldMapping = fieldLookup["G2Mvr"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.G2Mvr = GetMetaValues(measurement);
}
return(obj);
}
public override string GetValue(TypeMapping mapping)
{
return(mapping.Representative.IsVisibleOutsideAssembly()
? "Yes"
: "No");
}
static void WriteDeserializerCallClassMethod(TypeBuilder typeBuilder, ILGenerator il, Type type, int tag, MethodInfo setMethod, Type ownerType = null)
{
MethodBuilder method;
var local = il.DeclareLocal(type);
var hasTypeMapping = TypeMapping.ContainsKey(type);
il.Emit(OpCodes.Ldc_I4, tag);
il.Emit(OpCodes.Ldarg_3);
il.Emit(OpCodes.Call, MoveToNextBytesMethod);
if (hasTypeMapping)
{
var index = 0;
var typeMapping = TypeMapping[type];
var count = typeMapping.Count;
var types = typeMapping.Select(kv => kv.Key);
var needBranchLabel = count > 1;
var branchLabel = needBranchLabel ? il.DefineLabel() : DefaultLabel;
var valueTypeLocal = il.DeclareLocal(TypeType);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldtoken, type);
il.Emit(OpCodes.Call, GetTypeFromHandleMethod);
il.Emit(OpCodes.Ldarg_3);
il.Emit(OpCodes.Call, ConvertBaseToConcreteTypeMethod);
il.Emit(OpCodes.Stloc, valueTypeLocal.LocalIndex);
foreach (var mapType in types)
{
index++;
var isLastIndex = index == count;
var isLastCondition = isLastIndex && needBranchLabel;
var conditionLabel = !isLastCondition?il.DefineLabel() : DefaultLabel;
var currentConditionLabel = isLastCondition ? branchLabel : conditionLabel;
il.Emit(OpCodes.Ldloc, valueTypeLocal.LocalIndex);
il.Emit(OpCodes.Ldtoken, mapType);
il.Emit(OpCodes.Call, GetTypeFromHandleMethod);
il.Emit(OpCodes.Call, GetTypeOpEqualityMethod);
il.Emit(OpCodes.Brfalse, currentConditionLabel);
method = GenerateDeserializerClass(typeBuilder, mapType, ownerType: ownerType);
il.Emit(OpCodes.Newobj, mapType.GetConstructor(Type.EmptyTypes));
il.Emit(OpCodes.Stloc, local.LocalIndex);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldloc, local.LocalIndex);
if (mapType.IsClass)
{
il.Emit(OpCodes.Castclass, mapType);
}
else
{
il.Emit(OpCodes.Unbox_Any, mapType);
}
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldarg_3);
il.Emit(OpCodes.Call, method);
if (!isLastIndex)
{
il.Emit(OpCodes.Br, branchLabel);
}
il.MarkLabel(currentConditionLabel);
}
}
else
{
method = GenerateDeserializerClass(typeBuilder, type, ownerType: ownerType);
var isTypeClass = type.IsClass;
if (isTypeClass)
{
il.Emit(OpCodes.Newobj, type.GetConstructor(Type.EmptyTypes));
il.Emit(OpCodes.Stloc, local.LocalIndex);
}
else
{
il.Emit(OpCodes.Ldloca, local.LocalIndex);
il.Emit(OpCodes.Initobj, type);
}
il.Emit(OpCodes.Ldarg_0);
if (isTypeClass)
{
il.Emit(OpCodes.Ldloc, local.LocalIndex);
}
else
{
il.Emit(OpCodes.Ldloca, local.LocalIndex);
}
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldarg_3);
il.Emit(OpCodes.Call, method);
}
il.Emit(OpCodes.Ldarg_1);
il.Emit(OpCodes.Ldloc, local.LocalIndex);
il.Emit(OpCodes.Call, setMethod);
}
/// <summary>
/// Maps the given <paramref name="type"/> in <paramref name="typeMapping"/>.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="definition">The <see cref="IndexDefinition"/>.</param>
/// <param name="type">The <see cref="ITypeDefinition"/>.</param>
/// <param name="typeMapping">The <see cref="TypeMapping"/>.</param>
private static void MapType(IMansionContext context, IndexDefinition definition, ITypeDefinition type, TypeMapping typeMapping)
{
// map the type descriptor, if any
TypeMapping.TypeMappingDescriptor descriptor;
if (type.TryGetDescriptor(out descriptor))
descriptor.UpdateMapping(context, typeMapping);
// map all the properties of this type
MapProperties(context, type, typeMapping);
// map all the analysis components defined on this type
MapAnalysisComponents(context, type, definition);
// loop over all the children of this type
foreach (var childType in type.GetChildTypes(context))
{
// clone the parent mapping, children should include the properties of the parent
var childMapping = typeMapping.Clone(childType);
// map the the child
MapType(context, definition, childType, childMapping);
}
// append the mapping to the index definition
definition.Add(typeMapping);
}
public override string GetValue(TypeMapping mapping)
{
return(GetTokenString(mapping));
}
public virtual DifferenceType Diff(IDifferences differences, TypeMapping mapping)
{
return(Diff(differences, mapping[0], mapping[1]));
}
public void CreateProject(string projectName, string targetDirectory, TypeMapping inputMapping, TypeMapping outputMapping, string targetLanguage)
{
MappingCompiler mappingCompiler = CreateMappingCompiler();
TypeMapping compiledInput = mappingCompiler.GetTypeMapping(inputMapping.Identifier);
TypeMapping compiledOutput = mappingCompiler.GetTypeMapping(outputMapping.Identifier);
if (targetLanguage == "C#")
{
ECAClientUtilities.Template.CSharp.ProjectGenerator projectGenerator = new ECAClientUtilities.Template.CSharp.ProjectGenerator(projectName, mappingCompiler);
projectGenerator.Settings.SubscriberConnectionString = MainWindow.Model.Global.SubscriptionConnectionString;
projectGenerator.Generate(targetDirectory, compiledInput, compiledOutput);
}
else if (targetLanguage == "F#")
{
ECAClientUtilities.Template.FSharp.ProjectGenerator projectGenerator = new ECAClientUtilities.Template.FSharp.ProjectGenerator(projectName, mappingCompiler);
projectGenerator.Settings.SubscriberConnectionString = MainWindow.Model.Global.SubscriptionConnectionString;
projectGenerator.Generate(targetDirectory, compiledInput, compiledOutput);
}
else if (targetLanguage == "VB")
{
ECAClientUtilities.Template.VisualBasic.ProjectGenerator projectGenerator = new ECAClientUtilities.Template.VisualBasic.ProjectGenerator(projectName, mappingCompiler);
projectGenerator.Settings.SubscriberConnectionString = MainWindow.Model.Global.SubscriptionConnectionString;
projectGenerator.Generate(targetDirectory, compiledInput, compiledOutput);
}
else if (targetLanguage == "IronPython")
{
ECAClientUtilities.Template.IronPython.ProjectGenerator projectGenerator = new ECAClientUtilities.Template.IronPython.ProjectGenerator(projectName, mappingCompiler);
projectGenerator.Settings.SubscriberConnectionString = MainWindow.Model.Global.SubscriptionConnectionString;
projectGenerator.Generate(targetDirectory, compiledInput, compiledOutput);
}
else if (targetLanguage == "MATLAB")
{
ECAClientUtilities.Template.Matlab.ProjectGenerator projectGenerator = new ECAClientUtilities.Template.Matlab.ProjectGenerator(projectName, mappingCompiler);
projectGenerator.Settings.SubscriberConnectionString = MainWindow.Model.Global.SubscriptionConnectionString;
projectGenerator.Generate(targetDirectory, compiledInput, compiledOutput);
}
else if (targetLanguage == "Java")
{
}
else if (targetLanguage == "C++")
{
}
else if (targetLanguage == "Python")
{
}
}
private TypeMapping ParseTimeWindow(TypeMapping typeMapping)
{
for (int i = 0; i < typeMapping.FieldMappings.Count; ++i)
{
if (typeMapping.FieldMappings[i].TimeWindowExpression != "")
{
try
{
int index = 0;
string[] parts = typeMapping.FieldMappings[i].TimeWindowExpression.Split(new char[0], StringSplitOptions.RemoveEmptyEntries);
if (parts[index].Equals("last", StringComparison.OrdinalIgnoreCase))
{
ArrayMapping am = new ArrayMapping();
am.Field = typeMapping.FieldMappings[i].Field;
am.Expression = typeMapping.FieldMappings[i].Expression;
am.RelativeTime = typeMapping.FieldMappings[i].RelativeTime;
am.RelativeUnit = typeMapping.FieldMappings[i].RelativeUnit;
am.SampleRate = typeMapping.FieldMappings[i].SampleRate;
am.SampleUnit = typeMapping.FieldMappings[i].SampleUnit;
am.TimeWindowExpression = "";
am.WindowSize = Convert.ToDecimal(parts[++index]);
++index;
if (parts[index].Equals("points", StringComparison.OrdinalIgnoreCase))
{
index += 2;
am.WindowUnit = TimeSpan.Zero;
if (parts.Length - 1 > index)
{
am.SampleRate = Convert.ToDecimal(parts[index]);
index += 2;
am.SampleUnit = GetTimeSpan(parts[index]);
}
}
else
{
am.WindowUnit = GetTimeSpan(parts[index]);
index += 2;
if (parts.Length - 1 > index)
{
am.SampleRate = Convert.ToDecimal(parts[index]);
index += 2;
am.SampleUnit = GetTimeSpan(parts[index]);
}
}
typeMapping.FieldMappings.RemoveAt(i);
am.TimeWindowExpression = "";
typeMapping.FieldMappings.Insert(i, am);
}
else if (parts[index].Equals("from", StringComparison.OrdinalIgnoreCase))
{
ArrayMapping am = new ArrayMapping();
am.Field = typeMapping.FieldMappings[i].Field;
am.Expression = typeMapping.FieldMappings[i].Expression;
am.RelativeTime = typeMapping.FieldMappings[i].RelativeTime;
am.RelativeUnit = typeMapping.FieldMappings[i].RelativeUnit;
am.SampleRate = typeMapping.FieldMappings[i].SampleRate;
am.SampleUnit = typeMapping.FieldMappings[i].SampleUnit;
am.TimeWindowExpression = "";
am.RelativeTime = Convert.ToDecimal(parts[++index]);
++index;
if (parts[index].Equals("points", StringComparison.OrdinalIgnoreCase))
{
am.RelativeUnit = TimeSpan.Zero;
}
else
{
am.RelativeUnit = GetTimeSpan(parts[index]);
}
index += 3;
am.WindowSize = Convert.ToDecimal(parts[index++]);
if (parts[index].Equals("points", StringComparison.OrdinalIgnoreCase))
{
am.WindowUnit = TimeSpan.Zero;
}
else
{
am.WindowUnit = GetTimeSpan(parts[index]);
}
if (parts.Length > ++index)
{
am.SampleRate = Convert.ToDecimal(parts[++index]);
index += 2;
am.SampleUnit = GetTimeSpan(parts[index]);
}
typeMapping.FieldMappings.RemoveAt(i);
am.TimeWindowExpression = "";
typeMapping.FieldMappings.Insert(i, am);
}
else
{
typeMapping.FieldMappings[i].RelativeTime = Convert.ToDecimal(parts[index]);
++index;
if (parts[index].Equals("points", StringComparison.OrdinalIgnoreCase))
{
index += 3;
typeMapping.FieldMappings[i].RelativeUnit = TimeSpan.Zero;
if (parts.Length > index)
{
typeMapping.FieldMappings[i].SampleRate = Convert.ToDecimal(parts[index]);
index += 2;
typeMapping.FieldMappings[i].SampleUnit = GetTimeSpan(parts[index]);
}
}
else
{
typeMapping.FieldMappings[i].RelativeUnit = GetTimeSpan(parts[index]);
index += 3;
if (parts.Length - 1 > index)
{
typeMapping.FieldMappings[i].SampleRate = Convert.ToDecimal(parts[index]);
index += 2;
typeMapping.FieldMappings[i].SampleUnit = GetTimeSpan(parts[index]);
}
}
}
}
catch (Exception)
{
}
}
}
return(typeMapping);
}
private LVC.Model.test.Input CreatetestInput(TypeMapping typeMapping)
{
Dictionary <string, FieldMapping> fieldLookup = typeMapping.FieldMappings.ToDictionary(mapping => mapping.Field.Identifier);
LVC.Model.test.Input obj = new LVC.Model.test.Input();
{
// Assign short value to "TapVTx4" field
FieldMapping fieldMapping = fieldLookup["TapVTx4"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.TapVTx4 = (short)measurement.Value;
}
{
// Assign double value to "MwVTx4" field
FieldMapping fieldMapping = fieldLookup["MwVTx4"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.MwVTx4 = (double)measurement.Value;
}
{
// Assign double value to "MvrVTx4" field
FieldMapping fieldMapping = fieldLookup["MvrVTx4"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.MvrVTx4 = (double)measurement.Value;
}
{
// Assign double value to "VoltsVTx4" field
FieldMapping fieldMapping = fieldLookup["VoltsVTx4"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.VoltsVTx4 = (double)measurement.Value;
}
{
// Assign short value to "TapVTx5" field
FieldMapping fieldMapping = fieldLookup["TapVTx5"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.TapVTx5 = (short)measurement.Value;
}
{
// Assign double value to "MwVTx5" field
FieldMapping fieldMapping = fieldLookup["MwVTx5"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.MwVTx5 = (double)measurement.Value;
}
{
// Assign double value to "MvrVTx5" field
FieldMapping fieldMapping = fieldLookup["MvrVTx5"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.MvrVTx5 = (double)measurement.Value;
}
{
// Assign double value to "VoltsVTx5" field
FieldMapping fieldMapping = fieldLookup["VoltsVTx5"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.VoltsVTx5 = (double)measurement.Value;
}
{
// Assign short value to "BusBkrVCap1" field
FieldMapping fieldMapping = fieldLookup["BusBkrVCap1"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.BusBkrVCap1 = (short)measurement.Value;
}
{
// Assign short value to "CapBkrVCap1" field
FieldMapping fieldMapping = fieldLookup["CapBkrVCap1"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.CapBkrVCap1 = (short)measurement.Value;
}
{
// Assign double value to "LocKvVCap1" field
FieldMapping fieldMapping = fieldLookup["LocKvVCap1"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.LocKvVCap1 = (double)measurement.Value;
}
{
// Assign short value to "BusBkrVCap2" field
FieldMapping fieldMapping = fieldLookup["BusBkrVCap2"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.BusBkrVCap2 = (short)measurement.Value;
}
{
// Assign short value to "CapBkrVCap2" field
FieldMapping fieldMapping = fieldLookup["CapBkrVCap2"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.CapBkrVCap2 = (short)measurement.Value;
}
{
// Assign double value to "LocKvVCap2" field
FieldMapping fieldMapping = fieldLookup["LocKvVCap2"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.LocKvVCap2 = (double)measurement.Value;
}
{
// Assign double value to "G1Mw" field
FieldMapping fieldMapping = fieldLookup["G1Mw"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.G1Mw = (double)measurement.Value;
}
{
// Assign double value to "G1Mvr" field
FieldMapping fieldMapping = fieldLookup["G1Mvr"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.G1Mvr = (double)measurement.Value;
}
{
// Assign double value to "G2Mw" field
FieldMapping fieldMapping = fieldLookup["G2Mw"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.G2Mw = (double)measurement.Value;
}
{
// Assign double value to "G2Mvr" field
FieldMapping fieldMapping = fieldLookup["G2Mvr"];
IMeasurement measurement = GetMeasurement(fieldMapping);
obj.G2Mvr = (double)measurement.Value;
}
return(obj);
}
private string StreamName(Guid correlationId) =>
TypeMapping.GetTypeName(typeof(TSaga)) + "-" + correlationId.ToString("N");
public IList <IColumnDefinition> GetColumnDefinitions(FolkeConnection connection, TypeMapping typeMap)
{
return(connection.Select <MySqlColumnDefinition>().All().From().Where(x => x.TABLE_NAME == typeMap.TableName && x.TABLE_SCHEMA == connection.Database).ToList().Cast <IColumnDefinition>().ToList());
}
private static void AddParameters <T, TMe>(ISetTarget <T, TMe> target, object value, TypeMapping typeMapping, SelectedTable table,
BaseQueryBuilder baseQueryBuilder, string baseName)
{
foreach (var property in typeMapping.Columns.Values)
{
if (property.Readonly)
{
continue;
}
var parameter = value != null?property.PropertyInfo.GetValue(value) : null;
if (property.Reference != null && property.Reference.IsComplexType)
{
AddParameters(target, parameter, property.Reference, table, baseQueryBuilder, property.ComposeName(baseName));
}
else
{
if (property.IsJson)
{
parameter = JsonConvert.SerializeObject(parameter);
}
target.AppendSet();
string tableName = table.Alias;
baseQueryBuilder.StringBuilder.DuringColumn(tableName, property.ComposeName(baseName));
baseQueryBuilder.StringBuilder.Append("=");
var index = baseQueryBuilder.AddParameter(parameter);
baseQueryBuilder.StringBuilder.DuringParameter(index);
}
}
}
public void Properties_Array()
{
SetConfig();
var mapping = new TypeMapping<ArrayObject, ArrayObject>();
var properties = mapping.Properties.ToList();
Assert.AreEqual(1, properties.Count);
Assert.IsTrue(properties.Contains("Id"));
}
static void WriteDeserializerReadValue(TypeBuilder typeBuilder, ILGenerator il, Type type, int tag, int itemLocalIndex)
{
var isCollection = type.IsCollectionType();
var isClass = !isCollection && type.IsComplexType();
if (isClass)
{
MethodBuilder method;
var hasTypeMapping = TypeMapping.ContainsKey(type);
if (hasTypeMapping)
{
var index = 0;
var typeMapping = TypeMapping[type];
var count = typeMapping.Count;
var types = typeMapping.Select(kv => kv.Key);
var needBranchLabel = count > 1;
var branchLabel = needBranchLabel ? il.DefineLabel() : DefaultLabel;
var valueTypeLocal = il.DeclareLocal(TypeType);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldtoken, type);
il.Emit(OpCodes.Call, GetTypeFromHandleMethod);
il.Emit(OpCodes.Ldarg_3);
il.Emit(OpCodes.Call, ConvertBaseToConcreteTypeMethod);
il.Emit(OpCodes.Stloc, valueTypeLocal.LocalIndex);
foreach (var mapType in types)
{
index++;
var isLastIndex = index == count;
var isLastCondition = isLastIndex && needBranchLabel;
var conditionLabel = !isLastCondition?il.DefineLabel() : DefaultLabel;
var currentConditionLabel = isLastCondition ? branchLabel : conditionLabel;
il.Emit(OpCodes.Ldloc, valueTypeLocal.LocalIndex);
il.Emit(OpCodes.Ldtoken, mapType);
il.Emit(OpCodes.Call, GetTypeFromHandleMethod);
il.Emit(OpCodes.Call, GetTypeOpEqualityMethod);
il.Emit(OpCodes.Brfalse, currentConditionLabel);
method = GenerateDeserializerClass(typeBuilder, mapType);
il.Emit(OpCodes.Newobj, mapType.GetConstructor(Type.EmptyTypes));
il.Emit(OpCodes.Stloc, itemLocalIndex);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldloc, itemLocalIndex);
if (mapType.IsClass)
{
il.Emit(OpCodes.Castclass, mapType);
}
else
{
il.Emit(OpCodes.Unbox_Any, mapType);
}
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldarg_3);
il.Emit(OpCodes.Call, method);
if (!isLastIndex)
{
il.Emit(OpCodes.Br, branchLabel);
}
il.MarkLabel(currentConditionLabel);
}
}
else
{
method = GenerateDeserializerClass(typeBuilder, type);
var isTypeClass = type.IsClass;
if (isTypeClass)
{
il.Emit(OpCodes.Newobj, type.GetConstructor(Type.EmptyTypes));
il.Emit(OpCodes.Stloc, itemLocalIndex);
}
else
{
il.Emit(OpCodes.Ldloca, itemLocalIndex);
il.Emit(OpCodes.Initobj, type);
}
il.Emit(OpCodes.Ldarg_0);
if (isTypeClass)
{
il.Emit(OpCodes.Ldloc, itemLocalIndex);
}
else
{
il.Emit(OpCodes.Ldloca, itemLocalIndex);
}
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldarg_3);
il.Emit(OpCodes.Call, method);
}
}
else if (isCollection)
{
WriteDeserializerClass(typeBuilder, il, type, tag, null, itemLocalIndex: itemLocalIndex);
}
else
{
var nonNullableType = type.GetNonNullableType();
var isTypeEnum = type.IsEnum;
var needTypeForReader = PrimitiveReadersWithTypes.Contains(isTypeEnum ? EnumType : nonNullableType);
il.Emit(OpCodes.Ldarg_2);
il.Emit(OpCodes.Ldarg_3);
il.Emit(OpCodes.Ldc_I4, 1);
il.Emit(OpCodes.Ldc_I4, type.IsBufferedTypeInt());
il.Emit(OpCodes.Call, ReadNextBytesMethod);
if (needTypeForReader)
{
il.Emit(OpCodes.Ldtoken, type);
il.Emit(OpCodes.Call, GetTypeFromHandleMethod);
}
if (isTypeEnum)
{
il.Emit(OpCodes.Call, PrimitiveReaderMethods[EnumType]);
}
else
{
il.Emit(OpCodes.Call, PrimitiveReaderMethods[nonNullableType]);
if (type.IsNullable())
{
il.Emit(OpCodes.Newobj, type.GetNullableTypeCtor());
}
}
if (needTypeForReader)
{
il.Emit(OpCodes.Unbox_Any, type);
}
il.Emit(OpCodes.Stloc, itemLocalIndex);
}
}
public void OrderBy_CanBuildExpression()
{
var mapping = new TypeMapping<IPerson, Person>();
var expression = mapping.OrderBy("p => p.Birthdate").Compile();
var persons = new List<IPerson>
{
new Person{ Id = 1, Birthdate = DateTime.Parse("1987-03-02") },
new Person{ Id = 2, Birthdate = DateTime.Parse("1987-03-01") },
};
var orderedPersons = persons.OrderBy(expression).ToList();
Assert.AreEqual(2, orderedPersons[0].Id);
}
public void Properties_Nested()
{
SetConfig();
var mapping = new TypeMapping<NestedObject, NestedObject>();
var properties = mapping.Properties.ToList();
Assert.AreEqual(4, properties.Count);
Assert.IsTrue(properties.Contains("OuterName"));
Assert.IsTrue(properties.Contains("Id"));
Assert.IsTrue(properties.Contains("Inner.Name"));
Assert.IsTrue(properties.Contains("Inner.Date"));
}
public virtual string GetValue(TypeMapping mapping)
{
return(null);
}
public PersistParameterBinding(TypeMapping typeMapping, int fieldIndex)
: this(typeMapping, fieldIndex, ParameterTransmissionType.Regular, PersistParameterBindingType.Regular)
{
}
public InjectableType GetInjectableType(TypeMapping tm) => PropInjectable.GetOrAdd(tm, () => CheckSuitable(tm));
/// <summary>
/// Creates the type mapping for the given <paramref name="type"/>.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="definition">The <see cref="IndexDefinition"/>.</param>
/// <param name="type">The <see cref="ITypeDefinition"/>.</param>
private static void CreateTypeMapping(IMansionContext context, IndexDefinition definition, ITypeDefinition type)
{
// create the type mapping
var typeMapping = new TypeMapping(type);
// map the type
MapType(context, definition, type, typeMapping);
}
private static void ConfigureContext()
{
var currentStatusPropertyConfig = new PropertyConfig("CurrentStatus")
{
Converter = typeof(StatusConverter)
};
var employeeMapping = new TypeMapping(typeof(Employee), "HashRangeTable");
employeeMapping.AddProperty(new PropertyConfig("ManagerName")
{
Attribute = "Manager"
});
employeeMapping.AddProperty(new PropertyConfig("CompanyName")
{
Attribute = "Company"
});
employeeMapping.AddProperty(new PropertyConfig("InternalId")
{
Ignore = true
});
employeeMapping.AddProperty(currentStatusPropertyConfig);
var employee2Mapping = new TypeMapping(typeof(Employee2), "HashRangeTable");
employee2Mapping.AddProperty(currentStatusPropertyConfig);
var employee3Mapping = new TypeMapping(typeof(Employee3), "HashRangeTable");
employee3Mapping.AddProperty(currentStatusPropertyConfig);
var versionedEmployeeMapping = new TypeMapping(typeof(VersionedEmployee), "FakeTable");
versionedEmployeeMapping.AddProperty(new PropertyConfig("Version")
{
Ignore = true
});
var context = AWSConfigsDynamoDB.Context;
context.TableAliases["FakeTable"] = "HashRangeTable";
//to save retries
if (!context.TypeMappings.ContainsKey(typeof(VersionedEmployee)))
{
context.AddMapping(versionedEmployeeMapping);
}
if (!context.TypeMappings.ContainsKey(typeof(Employee3)))
{
context.AddMapping(employee3Mapping);
}
if (!context.TypeMappings.ContainsKey(typeof(Employee2)))
{
context.AddMapping(employee2Mapping);
}
if (!context.TypeMappings.ContainsKey(typeof(Employee)))
{
context.AddMapping(employeeMapping);
}
}
/// <summary>
/// Maps the properties of the given <paramref name="type"/> in <paramref name="typeMapping"/>.
/// </summary>
/// <param name="context">The <see cref="IMansionContext"/>.</param>
/// <param name="type">The <see cref="ITypeDefinition"/>.</param>
/// <param name="typeMapping">The <see cref="TypeMapping"/>.</param>
private static void MapProperties(IMansionContext context, ITypeDefinition type, TypeMapping typeMapping)
{
// loop over all the properties to find those with descriptors
foreach (var property in type.Properties)
{
// try to get the property descriptor
PropertyMappingDescriptor descriptor;
if (!property.TryGetDescriptor(out descriptor))
continue;
// allow the descriptor to add property mappings to the type mapping
descriptor.AddMappingTo(context, property, typeMapping);
}
}
public IList <IColumnDefinition> GetColumnDefinitions(FolkeConnection connection, TypeMapping typeMap)
{
var list = new List <IColumnDefinition>();
using (var command = connection.CreateCommand())
{
command.CommandText = $"PRAGMA table_info({typeMap.TableName})";
using (var reader = command.ExecuteReader())
{
while (reader.Read())
{
list.Add(new SqliteColumnDefinition
{
ColumnName = reader.GetString(1),
ColumnType = reader.GetString(2)
});
}
}
}
return(list);
}
private async Task <string> InitProcessor(string indexName)
{
indexName = "gdst_" + indexName.ToLower();
_documentCount = (await _solrOperation.QueryAsync(SolrQuery.All, new QueryOptions()
{
StartOrCursor = new StartOrCursor.Start(0),
Rows = 1
})).NumFound;
_logger.LogInformation($"{indexName} NumFound :{_documentCount}");
var response = await _elasticClient.Indices.ExistsAsync(index : indexName.ToLower());
var solrSchema = await _solrOperation.GetSchemaAsync("schema.xml");
var filedTypes = solrSchema.SolrFields.Select(f => f.Type.Name).Distinct();
_logger.LogInformation($"total fields: {solrSchema.SolrFields.Count} Types: {string.Join(",", filedTypes)}");
if (!response.Exists)
{
var indexSettings = new IndexSettings()
{
NumberOfReplicas = 0
};
var properties = new Properties();
solrSchema.SolrFields.ForEach(sf =>
{
switch (sf.Type.Name)
{
case "int":
properties.Add(sf.Name, new NumberProperty(NumberType.Integer));
break;
case "double":
properties.Add(sf.Name, new NumberProperty(NumberType.Double));
break;
case "float":
properties.Add(sf.Name, new NumberProperty(NumberType.Float));
break;
case "string":
properties.Add(sf.Name, new KeywordProperty());
break;
case "date":
properties.Add(sf.Name, new DateProperty());
break;
case "location_rpt":
if (sf.Name == "GEO")
{
properties.Add(sf.Name, new GeoShapeProperty());
}
else
{
properties.Add(sf.Name, new GeoPointProperty());
}
break;
default:
properties.Add(sf.Name, new TextProperty());
break;
}
});
var typeMappings = new TypeMapping()
{
Properties = properties
};
_elasticClient.Indices.Create(indexName, p =>
p.InitializeUsing(new IndexState()
{
Settings = indexSettings,
Mappings = typeMappings
}));
}
return(indexName);
}
public override string GetValue(TypeMapping mapping)
{
return(GetObsoletionMarker(mapping));
}
public TypeMapperProvider(TypeMapping typeMapping)
{
_typeMapping = typeMapping;
}
public MemberConfigurator(TypeMapping typeMapping)
{
_typeMapping = typeMapping;
}
public LifetimeManager CreateLifetimeManager(TypeMapping typeMapping)
{
var customLifetimeManager = configurationDetails.IsMarkedWithCustomLifetimeManager(typeMapping.From);
return customLifetimeManager.Item1 ? customLifetimeManager.Item2 : new TransientLifetimeManager();
}
private void CollectFromECAPhasorCollection(List <IMeasurement> measurements, TypeMapping typeMapping, TVA_LSETestHarness.Model.ECA.PhasorCollection data, TVA_LSETestHarness.Model.ECA._PhasorCollectionMeta meta)
{
Dictionary <string, FieldMapping> fieldLookup = typeMapping.FieldMappings.ToDictionary(mapping => mapping.Field.Identifier);
{
// Convert values from TVA_LSETestHarness.Model.ECA.Phasor UDT array for "Phasors" field to measurements
ArrayMapping arrayMapping = (ArrayMapping)fieldLookup["Phasors"];
int dataLength = data.Phasors.Length;
int metaLength = meta.Phasors.Length;
if (dataLength != metaLength)
{
throw new InvalidOperationException($"Values array length ({dataLength}) and MetaValues array length ({metaLength}) for field \"Phasors\" must be the same.");
}
PushWindowFrameTime(arrayMapping);
for (int i = 0; i < dataLength; i++)
{
TypeMapping nestedMapping = GetUDTArrayTypeMapping(arrayMapping, i);
CollectFromECAPhasor(measurements, nestedMapping, data.Phasors[i], meta.Phasors[i]);
}
PopWindowFrameTime(arrayMapping);
}
}
/// <summary>
/// Initializes an instance of the EfMapping class
/// </summary>
/// <param name="db">The context to get the mapping from</param>
public EfMapping(DbContext db)
{
this.TypeMappings = new Dictionary<Type, TypeMapping>();
var metadata = ((IObjectContextAdapter)db).ObjectContext.MetadataWorkspace;
//EF61Test(metadata);
// Conceptual part of the model has info about the shape of our entity classes
var conceptualContainer = metadata.GetItems<EntityContainer>(DataSpace.CSpace).Single();
// Storage part of the model has info about the shape of our tables
var storeContainer = metadata.GetItems<EntityContainer>(DataSpace.SSpace).Single();
// Object part of the model that contains info about the actual CLR types
var objectItemCollection = ((ObjectItemCollection)metadata.GetItemCollection(DataSpace.OSpace));
// Loop thru each entity type in the model
foreach (var set in conceptualContainer.BaseEntitySets.OfType<EntitySet>())
{
// Find the mapping between conceptual and storage model for this entity set
var mapping = metadata.GetItems<EntityContainerMapping>(DataSpace.CSSpace)
.Single()
.EntitySetMappings
.Single(s => s.EntitySet == set);
var typeMapping = new TypeMapping
{
TableMappings = new List<TableMapping>(),
EntityType = GetClrType(metadata, objectItemCollection, set)
};
this.TypeMappings.Add(typeMapping.EntityType, typeMapping);
var tableMapping = new TableMapping
{
PropertyMappings = new List<PropertyMapping>(),
};
var mappingToLookAt = mapping.EntityTypeMappings.FirstOrDefault(m => m.IsHierarchyMapping) ?? mapping.EntityTypeMappings.First();
tableMapping.Schema = mappingToLookAt.Fragments[0].StoreEntitySet.Schema;
tableMapping.TableName = mappingToLookAt.Fragments[0].StoreEntitySet.Table ?? mappingToLookAt.Fragments[0].StoreEntitySet.Name;
typeMapping.TableMappings.Add(tableMapping);
Action<Type, System.Data.Entity.Core.Mapping.PropertyMapping, string> recurse = null;
recurse = (t, item, path) =>
{
if (item is ComplexPropertyMapping)
{
var complex = item as ComplexPropertyMapping;
foreach (var child in complex.TypeMappings[0].PropertyMappings)
{
recurse(t, child, path + complex.Property.Name + ".");
}
}
else if (item is ScalarPropertyMapping)
{
var scalar = item as ScalarPropertyMapping;
tableMapping.PropertyMappings.Add(new PropertyMapping
{
ColumnName = scalar.Column.Name,
DataType = scalar.Column.TypeName,
DataTypeFull = GetFullTypeName(scalar),
PropertyName = path + item.Property.Name,
ForEntityType = t
});
}
};
Func<MappingFragment, Type> getClr = m =>
{
return GetClrTypeFromTypeMapping(metadata, objectItemCollection, m.TypeMapping as EntityTypeMapping);
};
if (mapping.EntityTypeMappings.Any(m => m.IsHierarchyMapping))
{
var withConditions = mapping.EntityTypeMappings.Where(m => m.Fragments[0].Conditions.Any()).ToList();
tableMapping.TPHConfiguration = new TPHConfiguration
{
ColumnName = withConditions.First().Fragments[0].Conditions[0].Column.Name,
Mappings = new Dictionary<Type, string>()
};
foreach (var item in withConditions)
{
tableMapping.TPHConfiguration.Mappings.Add(
getClr(item.Fragments[0]),
((ValueConditionMapping)item.Fragments[0].Conditions[0]).Value.ToString()
);
}
}
foreach (var entityType in mapping.EntityTypeMappings)
{
foreach (var item in entityType.Fragments[0].PropertyMappings)
{
recurse(getClr(entityType.Fragments[0]), item, "");
}
}
//Inheriting propertymappings contains duplicates for id's.
tableMapping.PropertyMappings = tableMapping.PropertyMappings.GroupBy(p => p.PropertyName)
.Select(g => g.OrderByDescending(outer => g.Count(inner => inner.ForEntityType.IsSubclassOf(outer.ForEntityType))).First())
.ToList();
foreach (var item in tableMapping.PropertyMappings)
{
if ((mappingToLookAt.EntityType ?? mappingToLookAt.IsOfEntityTypes[0]).KeyProperties.Any(p => p.Name == item.PropertyName))
{
item.IsPrimaryKey = true;
}
}
}
}
public TVA_LSETestHarness.Model.ECA.PhasorCollection FillOutputData()
{
TypeMapping outputMapping = MappingCompiler.GetTypeMapping(OutputMapping);
return(FillECAPhasorCollection(outputMapping));
}
public virtual void Visit(TypeMapping type)
{
Visit(type.Fields);
Visit(type.Methods.Where(m => ((IMethodDefinition)m.Representative).IsConstructor));
Visit(type.Properties);
Visit(type.Events);
Visit(type.Methods.Where(m => !((IMethodDefinition)m.Representative).IsConstructor));
Visit((IEnumerable<TypeMapping>)type.NestedTypes);
}
public TVA_LSETestHarness.Model.ECA._PhasorCollectionMeta FillOutputMeta()
{
TypeMapping outputMeta = MappingCompiler.GetTypeMapping(OutputMapping);
return(FillECA_PhasorCollectionMeta(outputMeta));
}
public override void Visit(TypeMapping mapping)
{
Visit(mapping.Differences);
if (mapping.ShouldDiffMembers)
base.Visit(mapping);
}
private TVA_LSETestHarness.Model.ECA._PhasorCollectionMeta FillECA_PhasorCollectionMeta(TypeMapping typeMapping)
{
Dictionary <string, FieldMapping> fieldLookup = typeMapping.FieldMappings.ToDictionary(mapping => mapping.Field.Identifier);
TVA_LSETestHarness.Model.ECA._PhasorCollectionMeta obj = new TVA_LSETestHarness.Model.ECA._PhasorCollectionMeta();
{
// Initialize TVA_LSETestHarness.Model.ECA._PhasorMeta UDT array for "Phasors" field
ArrayMapping arrayMapping = (ArrayMapping)fieldLookup["Phasors"];
PushWindowFrameTime(arrayMapping);
List <TVA_LSETestHarness.Model.ECA._PhasorMeta> list = new List <TVA_LSETestHarness.Model.ECA._PhasorMeta>();
int count = GetUDTArrayTypeMappingCount(arrayMapping);
for (int i = 0; i < count; i++)
{
TypeMapping nestedMapping = GetUDTArrayTypeMapping(arrayMapping, i);
list.Add(FillECA_PhasorMeta(nestedMapping));
}
obj.Phasors = list.ToArray();
PopWindowFrameTime(arrayMapping);
}
return(obj);
}
public void Add(TypeMapping typeMapping)
{
Items.Add(typeMapping);
}
public DbMappingEntity(string tableId, TypeMapping typeMapping)
{
this.tableId = tableId;
TypeMapping = typeMapping;
}