/// ------------------------------------------------------------------------------------ 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)); }