/// ------------------------------------------------------------------------------------
public void PostDeserializeInitialization(PaProject project)
{
if (Type == DataSourceType.SA && FieldMappings.Count == 0)
{
// Make sure SA data sources have mappings. This check should really only be
// necessary when upgrading from a project last saved in version 3.0.1 of PA.
FieldMappings = CreateDefaultSaMappings(project.Fields).ToList();
}
else if (Type == DataSourceType.FW)
{
// Make sure FW6 data source mappings include all the default FW6 fields
// that cannot be mapped in the data source properties dialog box. This
// check should only be necessary the first time the project has been
// opened after having been migrated to version 3.3.0
foreach (var fname in Properties.Settings.Default.AllPossibleFw6Fields)
{
if (!Properties.Settings.Default.Fw6FieldsMappableInPropsDlg.Contains(fname) &&
!FieldMappings.Any(m => m.PaFieldName == fname))
{
FieldMappings.Add(new FieldMapping(
project.Fields.Single(f => f.Name == fname), false));
}
}
}
}
public void SameFieldCanTransformMultipleTimesWithDifferentNames()
{
var mappings = new FieldMappings();
mappings
.Field(f => f
.Name("path"))
.Field(f => f
.Name("path")
.Converter <SplitedIntArrayFieldConverter>()
.WithTransformName("intPath"))
.Field(f => f
.Name("path")
.Converter <JArrayFieldConverter>()
.WithTransformName("stringPath"));
var transformer = new Transformer(mappings);
var transformedObject = transformer.Transform(testData);
var isPathExist = transformedObject.Properties().Any(p => p.Name == "path");
var isIntPathExist = transformedObject.Properties().Any(p => p.Name == "intPath");
var isStringPathExist = transformedObject.Properties().Any(p => p.Name == "stringPath");
var isAllPathsExist = isPathExist && isIntPathExist && isStringPathExist;
isAllPathsExist.ShouldBeTrue();
}
protected void setupDisplayDataCascadingDropDown()
{
// now, let's set up the cascading
CascadingPair pair = new CascadingPair()
{
ParentDropDownID = ddlDataType.ID, ChildDropDownID = ddlDisplayType.ID
};
// and let's apply the dependencies properly
foreach (ListItem dataType in ddlDataType.Items)
{
var dependentDisplayTypes =
FieldMappings.GetDependentDisplayTypesFor(dataType.Value.ToEnum <FieldDataType>());
ParentDropDownValue v = new ParentDropDownValue()
{
Value = dataType.Value
};
foreach (var dependentDisplayType in dependentDisplayTypes)
{
v.ChildDropDownValues.Add(new ChildDropDownValue()
{
Value = dependentDisplayType.ToString()
});
}
pair.ParentDropDownValues.Add(v);
}
CascadingDropDownManager1.CascadingPairs.Add(pair);
}
/// <summary>
/// Gets the <see cref="DataModelColumnAttribute"/> having the
/// specified name and naming type.
/// </summary>
/// <param name="propertyNameOrColumnName"></param>
/// <returns></returns>
public DataModelColumnAttribute this[string propertyNameOrColumnName]
{
get
{
if (FieldMappings.ContainsKey(propertyNameOrColumnName))
{
return(FieldMappings[propertyNameOrColumnName]);
}
var ret = GetFieldMappingByDbColumnName(propertyNameOrColumnName);
if (ret != null)
{
return(ret);
}
if (ForeignModelMappings.ContainsKey(propertyNameOrColumnName))
{
if (FieldMappings.ContainsKey(ForeignModelMappings[propertyNameOrColumnName].TargetMember.Name))
{
return(FieldMappings[ForeignModelMappings[propertyNameOrColumnName].TargetMember.Name]);
}
var foreignMapping = ForeignModelMappings[propertyNameOrColumnName];
var mapping = FieldMappings.ToList().Find(fm => fm.Value.ColumnName == foreignMapping.LocalColumn).Value;
return(mapping);
}
return(null);
}
}
protected override void OnLoadComplete(EventArgs e)
{
if (!IsPostBack && FieldMappings.Count() > 0)
{
LoadFromMappings(true);
}
base.OnLoadComplete(e);
}
internal static FieldDescriptor GetFieldDescriptor(string fieldId, IDictionary <string, FieldDescriptor> customFields)
{
Preconditions.NotNullOrEmpty(fieldId, nameof(fieldId));
if (!FieldMappings.TryGetDescriptor(fieldId, out var descriptor) && customFields?.TryGetValue(fieldId, out descriptor) != true && !FieldPatternMappings.TryGetDescriptorForFieldId(fieldId, out descriptor))
{
throw new ArgumentException($"Could not find field '{fieldId}'");
}
return(descriptor);
}
internal static FieldDescriptor GetFieldDescriptor(string fieldId, IDictionary <string, FieldDescriptor> customFields, UndefinedCustomFieldHandling undefinedCustomFieldHandling)
{
Preconditions.NotNullOrEmpty(fieldId, nameof(fieldId));
if (!FieldMappings.TryGetDescriptor(fieldId, out var descriptor) && customFields?.TryGetValue(fieldId, out descriptor) != true && (!FieldPatternMappings.TryGetDescriptorForFieldId(fieldId, out descriptor) || (descriptor.Type == LoanFieldType.Custom && (undefinedCustomFieldHandling == UndefinedCustomFieldHandling.Error || (undefinedCustomFieldHandling == UndefinedCustomFieldHandling.ErrorIfCustomFieldsInitialized && (customFields?.Count ?? 0) != 0)))))
{
throw new ArgumentException($"Could not find field '{fieldId}'");
}
return(descriptor);
}
private void LoadForeignKeyMappingAttributes()
{
var hierarchy = new List <Type>();
var t = this.EntityType;
while (t != typeof(DataModel) && t != typeof(object))
{
hierarchy.Insert(0, t);
t = t.BaseType;
}
// walk up hierarchy
foreach (var type in hierarchy)
{
var pis = type.GetProperties();
var fis = type.GetFields();
var mis = new Dictionary <MemberInfo, Type>();
foreach (var fi in fis)
{
mis.Add(fi, fi.FieldType); // fee fi fo fum
}
foreach (var pi in pis)
{
mis.Add(pi, pi.PropertyType);
}
foreach (var mi_kvp in mis)
{
var mi = mi_kvp.Key;
var miType = mi_kvp.Value;
var attrs = mi.GetCustomAttributes(typeof(ForeignKeyAttribute), false);
foreach (ForeignKeyAttribute attr in attrs)
{
attr.TargetMember = mi;
attr.TargetMemberType = miType;
if (!FieldMappings.ContainsKey(mi.Name))
{
FieldMappings[mi.Name]
= new DataModelColumnAttribute(attr.ForeignColumn);
}
if (FieldMappings[mi.Name].ForeignKeyMapping != null && !attr.ClearBaseObjectMapping)
{
attr.CopyDeltaTo(FieldMappings[mi.Name].ForeignKeyMapping);
}
else
{
FieldMappings[mi.Name].ForeignKeyMapping = attr;
}
}
}
}
}
public void ExcluededFieldsShouldBeExcludedFromTransformedObject()
{
var mappings = new FieldMappings();
mappings
.ExcludeField("creatorID")
.ExcludeField("creatorName");
var transformer = new Transformer(mappings);
var transformedObject = transformer.Transform(testData);
var actual = transformedObject.Properties()
.Any(p => p.Name == "creatorID" || p.Name == "creatorName");
Assert.False(actual);
}
public void IntValueConverter()
{
var mappings = new FieldMappings();
mappings
.Field(f => f
.Name("parentID")
.Converter <IntFieldConverter>());
var transformer = new Transformer(mappings);
var transformedObject = transformer.Transform(testData);
var id = transformedObject["parentID"].ToObject <int>();
id.ShouldBe(14735);
}
public void FieldValueConvertersShouldBeChosenFromFieldSettings()
{
var mappings = new FieldMappings();
mappings
.Field(f => f
.Name("generalCapabilities")
.Converter <JArrayFieldConverter>());
var transformer = new Transformer(mappings);
var transformedObject = transformer.Transform(testData);
var generalCapabiltyCount = transformedObject["generalCapabilities"].Value <JArray>().Count;
generalCapabiltyCount.ShouldBe(8);
}
public override void PopulateMappings()
{
FieldMappings.Add(FieldType.Binary, new FieldMapInfo("nvarchar({0})", "200"));
FieldMappings.Add(FieldType.Bool, new FieldMapInfo("bit"));
FieldMappings.Add(FieldType.Char, new FieldMapInfo("nvarchar({0})", "1"));
FieldMappings.Add(FieldType.UnicodeChar, new FieldMapInfo("nvarchar({0})", "1"));
FieldMappings.Add(FieldType.Date, new FieldMapInfo("DATETIME"));
FieldMappings.Add(FieldType.Int, new FieldMapInfo("int"));
FieldMappings.Add(FieldType.Long, new FieldMapInfo("bigint"));
FieldMappings.Add(FieldType.Real, new FieldMapInfo("real"));
FieldMappings.Add(FieldType.Money, new FieldMapInfo("Money"));
FieldMappings.Add(FieldType.String, new FieldMapInfo("NVARCHAR({0})", "200"));
FieldMappings.Add(FieldType.Default, new FieldMapInfo("NVARCHAR({0})", "200"));
FieldMappings.Add(FieldType.Time, new FieldMapInfo("NVARCHAR(20)"));
FieldMappings.Add(FieldType.UnicodeString, new FieldMapInfo("NVARCHAR({0})", "200"));
FieldMappings.Add(FieldType.Text, new FieldMapInfo("ntext"));
FieldMappings.Add(FieldType.UnicodeText, new FieldMapInfo("ntext"));
}
public void SplitedIntegerArrayConverterShoulConvertValueToIntArray()
{
var mappings = new FieldMappings();
mappings
.Field(f => f
.Name("path")
.Converter <SplitedIntArrayFieldConverter>());
var transformer = new Transformer(mappings);
var transformedObject = transformer.Transform(testData);
var arr = transformedObject["path"].ToObject <int[]>();
var firstElementOfConvertedArray = arr[0];
firstElementOfConvertedArray.ShouldBe(-1);
}
public override void PopulateMappings()
{
FieldMappings.Add(FieldType.Binary, new FieldMapInfo("BLOB"));
FieldMappings.Add(FieldType.Bool, new FieldMapInfo("BOOL"));
FieldMappings.Add(FieldType.Char, new FieldMapInfo("VARCHAR"));
FieldMappings.Add(FieldType.UnicodeChar, new FieldMapInfo("VARCHAR"));
FieldMappings.Add(FieldType.Date, new FieldMapInfo("DATETIME"));
FieldMappings.Add(FieldType.Int, new FieldMapInfo("INTEGER"));
FieldMappings.Add(FieldType.Long, new FieldMapInfo("INTEGER"));
FieldMappings.Add(FieldType.Real, new FieldMapInfo("DOUBLE"));
FieldMappings.Add(FieldType.Money, new FieldMapInfo("DECIMAL"));
FieldMappings.Add(FieldType.String, new FieldMapInfo("VARCHAR"));
FieldMappings.Add(FieldType.Time, new FieldMapInfo("VARCHAR"));
FieldMappings.Add(FieldType.UnicodeString, new FieldMapInfo("VARCHAR"));
FieldMappings.Add(FieldType.Text, new FieldMapInfo("VARCHAR"));
FieldMappings.Add(FieldType.UnicodeText, new FieldMapInfo("VARCHAR"));
FieldMappings.Add(FieldType.Default, new FieldMapInfo("VARCHAR"));
}
public override void PopulateMappings()
{
FieldMappings.Add(FieldType.Binary, new FieldMapInfo("LONGBLOB"));
FieldMappings.Add(FieldType.Bool, new FieldMapInfo("TINYINT({0})", "1"));
FieldMappings.Add(FieldType.Char, new FieldMapInfo("VARCHAR({0})", "1"));
FieldMappings.Add(FieldType.UnicodeChar, new FieldMapInfo("VARCHAR({0}) CHARSET utf8", "1"));
FieldMappings.Add(FieldType.Date, new FieldMapInfo("DATETIME"));
FieldMappings.Add(FieldType.Int, new FieldMapInfo("INT({0})", "11"));
FieldMappings.Add(FieldType.Long, new FieldMapInfo("BIGINT({0})", "20"));
FieldMappings.Add(FieldType.Real, new FieldMapInfo("DOUBLE"));
FieldMappings.Add(FieldType.String, new FieldMapInfo("VARCHAR({0})", "200"));
FieldMappings.Add(FieldType.Money, new FieldMapInfo("NUMERIC"));
FieldMappings.Add(FieldType.Default, new FieldMapInfo("VARCHAR({0})", "200"));
FieldMappings.Add(FieldType.Time, new FieldMapInfo("TIME"));
FieldMappings.Add(FieldType.UnicodeString, new FieldMapInfo("VARCHAR({0}) CHARSET utf8", "200"));
FieldMappings.Add(FieldType.Text, new FieldMapInfo("LONGTEXT"));
FieldMappings.Add(FieldType.UnicodeText, new FieldMapInfo("LONGTEXT CHARSET utf8"));
}
public override void PopulateMappings()
{
FieldMappings.Add(FieldType.Binary, new FieldMapInfo("bytea[]"));
FieldMappings.Add(FieldType.Bool, new FieldMapInfo("boolean"));
FieldMappings.Add(FieldType.Char, new FieldMapInfo("character"));
FieldMappings.Add(FieldType.UnicodeChar, new FieldMapInfo("character"));
FieldMappings.Add(FieldType.Date, new FieldMapInfo("date"));
FieldMappings.Add(FieldType.Int, new FieldMapInfo("INTEGER"));
FieldMappings.Add(FieldType.Long, new FieldMapInfo("bigint"));
FieldMappings.Add(FieldType.Real, new FieldMapInfo("real"));
FieldMappings.Add(FieldType.Time, new FieldMapInfo("INTERVAL"));
FieldMappings.Add(FieldType.Money, new FieldMapInfo("NUMERIC"));
FieldMappings.Add(FieldType.String, new FieldMapInfo("character varying"));
FieldMappings.Add(FieldType.Default, new FieldMapInfo("character varying"));
FieldMappings.Add(FieldType.UnicodeString, new FieldMapInfo("character varying"));
FieldMappings.Add(FieldType.Text, new FieldMapInfo("text"));
FieldMappings.Add(FieldType.UnicodeText, new FieldMapInfo("text"));
}
public void InitializeFieldMappings()
{
FieldMappings.InitializeFieldMappings(ConnectionString);
accounts1.AddReadOnlyMappings();
//Add two blank field mapping controls, each initialized with the default list of manual field mappings
accounts1.AddNewMapping(FieldMappings.BCMAccountFields.BCMFields.UnMappedFields, FieldMappings.OCMAccountFields.OCMFields.UnMappedFields);
accounts1.AddNewMapping(FieldMappings.BCMAccountFields.BCMFields.UnMappedFields, FieldMappings.OCMAccountFields.OCMFields.UnMappedFields);
businessContacts1.AddReadOnlyMappings();
//Add one field mapping control for custom field
businessContacts1.AddNewMapping(FieldMappings.BCMBusinessContactFields.BCMFields.UnMappedFields, FieldMappings.OCMBusinessContactFields.OCMFields.UnMappedFields);
opportunities1.AddReadOnlyMappings();
//Add one field mapping control for custom field
opportunities1.AddNewMapping(FieldMappings.BCMOpportunityFields.BCMFields.UnMappedFields, FieldMappings.OCMDealFields.OCMFields.UnMappedFields);
Invalidate();
}
public void ObjValueConverter()
{
var mappings = new FieldMappings();
mappings
.Field(f => f
.Name("objectField")
.Converter <JObjectFieldConverter>());
var transformer = new Transformer(mappings);
var transformedObject = transformer.Transform(testData);
var nestedObject = transformedObject["objectField"].ToObject <JObject>();
var nestedObjectFirstField = nestedObject.Properties().FirstOrDefault();
nestedObjectFirstField.Name.ShouldBe("generalCapability");
nestedObjectFirstField.Value.ShouldBe("15");
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Makes a deep copy of the data source.
/// </summary>
/// ------------------------------------------------------------------------------------
public PaDataSource Copy()
{
return(new PaDataSource
{
SourceFile = SourceFile,
Type = Type,
ParseType = ParseType,
FirstInterlinearField = FirstInterlinearField,
Editor = Editor,
LastModification = LastModification,
SfmRecordMarker = SfmRecordMarker,
SkipLoadingBecauseOfProblem = SkipLoadingBecauseOfProblem,
SkipLoading = SkipLoading,
ToolboxSortField = ToolboxSortField,
TotalLinesInFile = TotalLinesInFile,
XSLTFile = XSLTFile,
FwDataSourceInfo = (FwDataSourceInfo == null ? null : FwDataSourceInfo.Copy()),
FieldMappings = (FieldMappings == null ? null : FieldMappings.Select(m => m.Copy()).ToList()),
});
}
public void TransformNameShouldBeSameWithTheSettings()
{
var mappings = new FieldMappings();
mappings
.Field(f => f
.Name("nodeTypeAlias")
.WithTransformName("alias"));
var transformer = new Transformer(mappings);
var transformedObject = transformer.Transform(testData);
var isFieldsWithTransformNameExist = transformedObject.Properties()
.Any(p => p.Name == "alias");
var isTransformedFieldRemoved = !transformedObject.Properties()
.Any(p => p.Name == "nodeTypeAlias");
isFieldsWithTransformNameExist.ShouldBeTrue();
isTransformedFieldRemoved.ShouldBeTrue();
}
protected virtual void Update()
{
this.Validate();
if (this.IsValid)
{
bool shouldNavigate = (Entity.ID == 0);
if (FieldMappings.Count() > 0)
{
LoadFromMappings(false);
}
EasyContext.Entry <ENTITY>(Entity).State = (Entity.ID == 0) ? EntityState.Added : EntityState.Modified;
EasyContext.SaveChanges();
if (shouldNavigate)
{
Response.Redirect(Request.Url.ToString().Split('?').First() + "?id=" + Entity.ID);
}
}
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Checks to see that SFM/Toolbox data source files actually contain the markers
/// that have been mapped to PA fields.
/// </summary>
/// ------------------------------------------------------------------------------------
public bool VerifyMappings()
{
if (Type != DataSourceType.Toolbox && Type != DataSourceType.SFM)
{
return(true);
}
m_markersInFile = null;
var badMappingFound = false;
var markers = GetSfMarkers(false).ToArray();
for (int i = FieldMappings.Count - 1; i >= 0; i--)
{
if (!markers.Contains(FieldMappings[i].NameInDataSource))
{
FieldMappings.RemoveAt(i);
badMappingFound = true;
}
}
return(!badMappingFound);
}
public override string MapFieldType(FieldType type, DataFieldInfo dfi)
{
if (type == FieldType.UserString)
{
return(dfi.DataFieldString);
}
else
{
if (dfi.DataFieldType != FieldType.Default)
{
FieldMapInfo info = FieldMappings[dfi.DataFieldType];
return(string.Format(info.TypeString, ResolveLength(dfi.FieldLength, info.DefaultLength)));
}
else if (FieldMappings.ContainsKey(type))
{
FieldMapInfo info = FieldMappings[type];
return(string.Format(info.TypeString, ResolveLength(dfi.FieldLength, info.DefaultLength)));
}
else
{
return("nvarchar(200)");
}
}
}
static LoanFieldDescriptors()
{
// Use embedded resource file for built-in field mappings to save assembly space
using (var stream = typeof(LoanFieldDescriptors).GetTypeInfo().Assembly.GetManifestResourceStream("EncompassRest.LoanFields.zip"))
{
using (var zip = new ZipArchive(stream))
{
using (var jsonStream = zip.GetEntry("LoanFields.json").Open())
{
using (var sr = new StreamReader(jsonStream))
{
using (var jr = new JsonTextReader(sr))
{
var loanFields = JsonHelper.DefaultPublicSerializer.Deserialize <List <StandardFieldInfo> >(jr);
foreach (var loanField in loanFields)
{
var modelPath = loanField.ModelPath;
FieldDescriptor descriptor;
if (loanField.Format.HasValue)
{
descriptor = new NonStandardFieldDescriptor(loanField.FieldId, CreateModelPath(modelPath), modelPath, loanField.Description, loanField.Format, loanField.Options, loanField.ReadOnly ?? false);
}
else
{
descriptor = new FieldDescriptor(loanField.FieldId, CreateModelPath(modelPath), modelPath, loanField.Description);
}
FieldMappings.AddField(descriptor);
}
}
}
}
using (var jsonStream = zip.GetEntry("VirtualFields.json").Open())
{
using (var sr = new StreamReader(jsonStream))
{
using (var jr = new JsonTextReader(sr))
{
var virtualFields = JsonHelper.DefaultPublicSerializer.Deserialize <List <VirtualFieldInfo> >(jr);
foreach (var virtualField in virtualFields)
{
var modelPath = $"Loan.VirtualFields['{virtualField.FieldId}']";
var descriptor = new NonStandardFieldDescriptor(virtualField.FieldId, CreateModelPath(modelPath), modelPath, virtualField.Description, virtualField.Format, virtualField.Options, readOnly: true);
FieldMappings.AddField(descriptor);
}
}
}
}
using (var jsonStream = zip.GetEntry("LoanFieldPatterns.json").Open())
{
using (var sr = new StreamReader(jsonStream))
{
using (var jr = new JsonTextReader(sr))
{
var loanFieldPatterns = JsonHelper.DefaultPublicSerializer.Deserialize <List <StandardFieldInfo> >(jr);
foreach (var loanFieldPattern in loanFieldPatterns)
{
var modelPathPattern = loanFieldPattern.ModelPath;
var descriptor = new FieldDescriptor(loanFieldPattern.FieldId, CreateModelPath(string.Format(modelPathPattern, 1)), modelPathPattern, loanFieldPattern.Description, multiInstance: true);
FieldPatternMappings.AddField(descriptor);
}
}
}
}
using (var jsonStream = zip.GetEntry("VirtualFieldPatterns.json").Open())
{
using (var sr = new StreamReader(jsonStream))
{
using (var jr = new JsonTextReader(sr))
{
var virtualFieldPatterns = JsonHelper.DefaultPublicSerializer.Deserialize <List <VirtualFieldInfo> >(jr);
foreach (var virtualFieldPattern in virtualFieldPatterns)
{
var modelPathPattern = $"Loan.VirtualFields['{virtualFieldPattern.FieldId}']";
var descriptor = new NonStandardFieldDescriptor(virtualFieldPattern.FieldId, CreateModelPath(string.Format(modelPathPattern, 1)), modelPathPattern, virtualFieldPattern.Description, virtualFieldPattern.Format, virtualFieldPattern.Options, readOnly: true, multiInstance: true);
FieldPatternMappings.AddField(descriptor);
}
}
}
}
}
}
}
protected ClassMapping <T> Map(string field, string property)
{
FieldMappings.Add(field, property);
return(this);
}
/// <summary>
/// Refreshes the standard fields cache.
/// </summary>
/// <param name="client">The client to use to retrieve the standard fields.</param>
/// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <see cref="CancellationToken.None"/>.</param>
/// <returns></returns>
public static async Task RefreshStandardFieldsAsync(EncompassRestClient client, CancellationToken cancellationToken = default)
{
Preconditions.NotNull(client, nameof(client));
var entityTypes = (await client.Schema.GetLoanSchemaAsync(includeFieldExtensions: true, cancellationToken).ConfigureAwait(false)).EntityTypes;
var loanEntitySchema = entityTypes["Loan"];
var fields = new Dictionary <string, StandardFieldInfo>(StringComparer.OrdinalIgnoreCase);
var fieldPatterns = new Dictionary <string, StandardFieldInfo>(StringComparer.OrdinalIgnoreCase)
{
{ "CX.{0}", new StandardFieldInfo {
FieldId = "CX.{0}", ModelPath = "Loan.CustomFields[(FieldName == 'CX.{0}')].StringValue", Format = LoanFieldFormat.STRING
} },
{ "CUST{0:00}FV", new StandardFieldInfo {
FieldId = "CUST{0:00}FV", ModelPath = "Loan.CustomFields[(FieldName == 'CUST{0:00}FV')].StringValue", Format = LoanFieldFormat.STRING
} }
};
PopulateFieldMappings("Loan", "Loan", null, loanEntitySchema, null, entityTypes, fields, fieldPatterns, extendedFieldInfo: true, null, null, null);
foreach (var pair in FieldMappings._standardFields)
{
var fieldId = pair.Key;
var currentDescriptor = pair.Value;
if (fields.TryGetValue(fieldId, out var fieldInfo))
{
fields.Remove(fieldId);
if (!string.Equals(currentDescriptor.ModelPath, fieldInfo.ModelPath, StringComparison.OrdinalIgnoreCase) || (!string.IsNullOrEmpty(fieldInfo.Description) && currentDescriptor.Description != fieldInfo.Description) || currentDescriptor.ReadOnly != (fieldInfo.ReadOnly == true))
{
var modelPath = string.Equals(currentDescriptor.ModelPath, fieldInfo.ModelPath, StringComparison.OrdinalIgnoreCase) ? currentDescriptor.ModelPath : fieldInfo.ModelPath;
var descriptor = new NonStandardFieldDescriptor(fieldInfo.FieldId, CreateModelPath(modelPath), modelPath, fieldInfo.Description, fieldInfo.Format, fieldInfo.Options, fieldInfo.ReadOnly == true);
FieldMappings._standardFields[fieldId] = descriptor;
}
}
else if (!currentDescriptor._userAdded)
{
FieldMappings._standardFields.TryRemove(fieldId, out _);
}
}
foreach (var pair in fields)
{
var fieldInfo = pair.Value;
var modelPath = fieldInfo.ModelPath;
var descriptor = new NonStandardFieldDescriptor(fieldInfo.FieldId, CreateModelPath(modelPath), modelPath, fieldInfo.Description, fieldInfo.Format, fieldInfo.Options, fieldInfo.ReadOnly == true);
FieldMappings.AddField(descriptor);
}
foreach (var pair in FieldPatternMappings._standardFieldPatterns)
{
var fieldPattern = pair.Key;
var currentDescriptor = pair.Value;
if (fieldPatterns.TryGetValue(fieldPattern, out var fieldInfo))
{
fieldPatterns.Remove(fieldPattern);
if (!string.Equals(currentDescriptor.ModelPath, fieldInfo.ModelPath, StringComparison.OrdinalIgnoreCase) || currentDescriptor.ReadOnly != (fieldInfo.ReadOnly == true))
{
var modelPathPattern = string.Equals(currentDescriptor.ModelPath, fieldInfo.ModelPath, StringComparison.OrdinalIgnoreCase) ? currentDescriptor.ModelPath : fieldInfo.ModelPath;
var descriptor = new NonStandardFieldDescriptor(fieldInfo.FieldId, CreateModelPath(string.Format(modelPathPattern, 1)), modelPathPattern, currentDescriptor.Description, fieldInfo.Format, fieldInfo.Options, fieldInfo.ReadOnly == true, multiInstance: true);
FieldPatternMappings._standardFieldPatterns[fieldPattern] = descriptor;
}
}
else if (!currentDescriptor._userAdded)
{
FieldPatternMappings._standardFieldPatterns.TryRemove(fieldPattern, out _);
}
}
foreach (var pair in fieldPatterns)
{
var fieldInfo = pair.Value;
var modelPathPattern = fieldInfo.ModelPath;
var descriptor = new NonStandardFieldDescriptor(fieldInfo.FieldId, CreateModelPath(string.Format(modelPathPattern, 1)), modelPathPattern, fieldInfo.Description, fieldInfo.Format, fieldInfo.Options, fieldInfo.ReadOnly == true, multiInstance: true);
FieldPatternMappings.AddField(descriptor);
}
StandardFieldsLastRefreshedUtc = DateTime.UtcNow;
}
private void LoadFieldMappingAttributes()
{
var hierarchy = new List <Type>();
var t = this.EntityType;
while (t != typeof(DataModel) && t != typeof(object))
{
hierarchy.Insert(0, t);
t = t.BaseType;
}
// walk up hierarchy
foreach (var type in hierarchy)
{
var pis = type.GetProperties();
var fis = type.GetFields();
var mis = new Dictionary <MemberInfo, Type>();
foreach (var fi in fis)
{
mis.Add(fi, fi.FieldType); // fee fi fo fum
}
foreach (var pi in pis)
{
mis.Add(pi, pi.PropertyType);
}
foreach (var mi_kvp in mis)
{
var mi = mi_kvp.Key;
var miType = mi_kvp.Value;
var attrs = mi.GetCustomAttributes(typeof(DataModelColumnAttribute), false);
if (!TypeIsFieldMappable(miType))
{
if (attrs.Length > 0)
{
throw new InvalidAttributeException("Cannot apply a " + typeof(DataModelColumnAttribute).Name
+ " to a member having a custom or complex type. "
+ "Use " + typeof(ForeignDataModelAttribute).Name + ".",
mi.Name, (Attribute)attrs[0]);
}
continue;
}
foreach (DataModelColumnAttribute attr in attrs)
{
attr.TargetMember = mi;
attr.TargetMemberType = miType;
if (string.IsNullOrEmpty(attr.ColumnName))
{
attr.ColumnName = mi.Name;
attr.IsColumnNameInferred = true;
}
if (FieldMappings.ContainsKey(mi.Name) && !attr.ClearBaseObjectMapping)
{
attr.CopyDeltaTo(FieldMappings[mi.Name]);
}
else
{
FieldMappings[mi.Name] = attr;
}
var fm = FieldMappings[mi.Name];
if (fm.DataType == null)
{
var def = miType;
Type[] genargs;
if (def.IsGenericType &&
(genargs = def.GetGenericArguments()).Length == 1)
{
def = genargs[0];
}
try
{
fm.DbType = DbTypeConverter.ToDbType(def);
}
catch { }
}
}
}
}
if ((FieldMappings.Count == 0 && TableMapping.PropertyLoadBehavior
== InferProperties.OnlyAttributedOrAllIfNoneHaveAttributes) ||
TableMapping.PropertyLoadBehavior == InferProperties.NotIgnored)
{
foreach (var type in hierarchy)
{
var pis = type.GetProperties(BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance);
var fis = type.GetFields(BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Instance);
var mis = new Dictionary <MemberInfo, Type>();
foreach (var fi in fis)
{
mis.Add(fi, fi.FieldType); // fee fi fo fum
}
foreach (var pi in pis)
{
mis.Add(pi, pi.PropertyType);
}
foreach (var mi_kvp in mis)
{
var mi = mi_kvp.Key;
if (!FieldMappings.ContainsKey(mi.Name))
{
var miType = mi_kvp.Value;
var ignoreAttrib = mi.GetCustomAttributes(typeof(DataModelIgnoreAttribute), false);
if (ignoreAttrib != null && ignoreAttrib.Length > 0)
{
continue;
}
var gt = miType;
if (!TypeIsFieldMappable(gt))
{
continue;
}
var attr = new DataModelColumnAttribute(mi.Name);
attr.TargetMember = mi;
attr.TargetMemberType = miType;
FieldMappings[mi.Name] = attr;
var fm = attr;
if (fm.DataType == null)
{
var def = miType;
Type[] genargs;
if (def.IsGenericType &&
(genargs = def.GetGenericArguments()).Length == 1)
{
def = genargs[0];
}
try
{
fm.DbType = DbTypeConverter.ToDbType(def);
}
catch
{
}
}
}
}
}
}
}
void IUtf8JsonSerializable.Write(Utf8JsonWriter writer)
{
writer.WriteStartObject();
writer.WritePropertyName("name");
writer.WriteStringValue(Name);
if (Description != null)
{
writer.WritePropertyName("description");
writer.WriteStringValue(Description);
}
writer.WritePropertyName("dataSourceName");
writer.WriteStringValue(DataSourceName);
if (SkillsetName != null)
{
writer.WritePropertyName("skillsetName");
writer.WriteStringValue(SkillsetName);
}
writer.WritePropertyName("targetIndexName");
writer.WriteStringValue(TargetIndexName);
if (Schedule != null)
{
writer.WritePropertyName("schedule");
writer.WriteObjectValue(Schedule);
}
if (Parameters != null)
{
writer.WritePropertyName("parameters");
writer.WriteObjectValue(Parameters);
}
if (FieldMappings != null && FieldMappings.Any())
{
writer.WritePropertyName("fieldMappings");
writer.WriteStartArray();
foreach (var item in FieldMappings)
{
writer.WriteObjectValue(item);
}
writer.WriteEndArray();
}
if (OutputFieldMappings != null && OutputFieldMappings.Any())
{
writer.WritePropertyName("outputFieldMappings");
writer.WriteStartArray();
foreach (var item in OutputFieldMappings)
{
writer.WriteObjectValue(item);
}
writer.WriteEndArray();
}
if (IsDisabled != null)
{
writer.WritePropertyName("disabled");
writer.WriteBooleanValue(IsDisabled.Value);
}
if (_etag != null)
{
writer.WritePropertyName("@odata.etag");
writer.WriteStringValue(_etag);
}
writer.WriteEndObject();
}
private void ExecuteFieldMapBehaviors()
{
// Auto-infer IsIdentity if no field is declared as primary key
// and no field is declared as identity and one member is named
// "ID" and that member is an int or a long.
bool hasPkOrIdent = false;
DataModelColumnAttribute idFieldMapping = null;
string typename = null;
foreach (var field_kvp in FieldMappings)
{
var field = field_kvp.Value;
if (!field.IsForeignKey)
{
if ((field.IsIdentity && field.IsIdentityDefined) ||
(field.IsPrimaryKey && field.IsPrimaryKeyDefined))
{
hasPkOrIdent = true;
}
if (typename == null)
{
typename = field.TargetMember.DeclaringType.Name.ToLower();
}
var propname = field.TargetMember.Name.ToLower();
if (propname == "id" || propname == typename + "id" || propname == typename + "_id")
{
idFieldMapping = field;
}
}
}
if (!hasPkOrIdent && idFieldMapping != null &&
(idFieldMapping.DbType == DbType.Int32 ||
idFieldMapping.DbType == DbType.Int64))
{
idFieldMapping.IsIdentity = true;
}
// Auto-infer a dictionary entry placeholder for foreign entity mappings
// with no referenced foreign key column
foreach (var fk in ForeignModelMappings)
{
//if (fk.Value.TargetMemberType.IsOrInherits(typeof(IEnumerable))) continue;
var tmt = GetEntityType(fk.Value.TargetMemberType);
var ttmap = GetEntityMapping(tmt);
var ff = ttmap != null
? ttmap.GetFieldMappingByDbColumnName(fk.Value.RelatedTableColumn)
: null;
if (FieldMappings.ToList().Exists(p => p
.Value.ColumnName.ToLower() == fk.Value.LocalColumn.ToLower()))
{
continue;
}
var fm = new DataModelColumnAttribute();
if (ff != null)
{
ff.CopyDeltaTo(fm);
fm.ColumnName = fk.Value.LocalColumn;
fm.DbType = fk.Value.LocalColumnDbType;
fm.SqlDbType = fk.Value.LocalColumnSqlDbType;
fm.ColumnSize = fk.Value.LocalColumnSize;
fm.IsNullable = fk.Value.LocalColumnIsNullable;
fm.TargetMember = fk.Value.TargetMember;
fm.TargetMemberType = fk.Value.TargetMemberType;
fm.IsPrimaryKey = false;
fm.IsIdentity = false;
FieldMappings.Add("field:" + fk.Value.LocalColumn, fm);
}
_FieldMapBehaviorsExecuted = true;
}
// predetermine NULLables based on CLR nullability
foreach (var field_kvp in FieldMappings)
{
var field = field_kvp.Value;
if (!field.IsNullableDefined)
{
var memtype = field.TargetMemberType;
bool nullable = !memtype.IsValueType;
if (memtype.IsGenericType && memtype.GetGenericTypeDefinition() == typeof(Nullable <>))
{
memtype = memtype.GetGenericArguments()[0];
nullable = true;
}
field.IsNullable = (memtype.IsValueType || memtype == typeof(string)) && nullable && !field.IsPrimaryKey;
}
}
}
/// <summary>
/// Updates the parent references of the data source and all child objects.
/// </summary>
public override void UpdateParentReferences(IConnection parentConnection)
{
base.UpdateParentReferences(parentConnection);
KeyMappings.ToList().ForEach(keyMapping => keyMapping.UpdateParentReferences(this));
FieldMappings.ToList().ForEach(fieldMapping => fieldMapping.UpdateParentReferences(this));
}
