/// <summary> /// Persists this mapping filter to the specified XmlElement /// </summary> /// <param name="filter">The filter to save</param> /// <param name="element"></param> internal static void Save(MappingsFilter filter, XmlElement element) { if (filter != null && filter.HasVersionFilter) { element.SetAttribute("sifVersion", filter.SifVersion); } else { element.RemoveAttribute("sifVersion"); } if (filter != null && filter.HasDirectionFilter) { element.SetAttribute("direction", filter.Direction.ToString("G")); switch (filter.Direction) { case MappingDirection.Inbound: element.SetAttribute("direction", "inbound"); break; case MappingDirection.Outbound: element.SetAttribute("direction", "outbound"); break; } } else { element.RemoveAttribute("direction"); } }
/** * Writes the mapping filter to an XML Element * @param filter * @param element The XML Element to write the filter to */ private void WriteFilterToXml(MappingsFilter filter, XmlElement element) { if (filter == null) { element.RemoveAttribute(ATTR_SIFVERSION); element.RemoveAttribute(ATTR_DIRECTION); } else { if (filter.HasVersionFilter) { element.SetAttribute(ATTR_SIFVERSION, filter.SifVersion); } else { element.RemoveAttribute(ATTR_SIFVERSION); } MappingDirection direction = filter.Direction; if (direction == MappingDirection.Inbound) { element.SetAttribute(ATTR_DIRECTION, "inbound"); } else if (direction == MappingDirection.Outbound) { element.SetAttribute(ATTR_DIRECTION, "outbound"); } else { element.RemoveAttribute(ATTR_DIRECTION); } } }
/** * Evaluates the filters defined for this FieldMapping. If any of the filters * evaluate to false, the FieldMapping is not added * * @param fieldMapping The FieldMapping to add * @return True if the FieldMapping was added. Otherwise false */ private bool AddRule(FieldMapping fieldMapping) { MappingsFilter filt = fieldMapping.Filter; // Filter out this rule? if (filt != null) { if (!filt.EvalDirection(fDirection) || !filt.EvalVersion(fSIFVersion)) { return(false); } } fFieldMappings.Add(fieldMapping); return(true); }
/// <summary> Creates a copy this ObjectMapping instance. /// /// </summary> /// <returns> A "deep copy" of this object /// </returns> public virtual FieldMapping Copy(ObjectMapping newParent) { FieldMapping m = new FieldMapping(); if (fNode != null && newParent.fNode != null) { m.fNode = (XmlElement)newParent.fNode.OwnerDocument.ImportNode(fNode, false); } m.FieldName = fField; m.DefaultValue = fDefValue; m.Alias = fAlias; m.ValueSetID = fValueSet; m.NullBehavior = fNullBehavior; if (fFilter != null) { MappingsFilter filtCopy = new MappingsFilter(); filtCopy.fVersion = fFilter.fVersion; filtCopy.fDirection = fFilter.fDirection; m.Filter = filtCopy; } m.DataType = fDatatype; if (fRule != null) { m.fRule = fRule.Copy(m); } else { m.fRule = null; } return(m); }
/** * Writes the values of this FieldMapping to the specified XML Element * * @param element The XML Element to write values to */ public void ToXml(XmlElement element) { XmlUtils.SetOrRemoveAttribute(element, ATTR_NAME, fField); if (fDatatype == SifDataType.String) { element.RemoveAttribute(ATTR_DATATYPE); } else { element.SetAttribute(ATTR_DATATYPE, fDatatype.ToString()); } XmlUtils.SetOrRemoveAttribute(element, ATTR_DEFAULT, fDefValue); XmlUtils.SetOrRemoveAttribute(element, ATTR_ALIAS, fAlias); XmlUtils.SetOrRemoveAttribute(element, ATTR_VALUESET, fValueSet); MappingsFilter filt = Filter; if (filt != null) { WriteFilterToXml(filt, element); } WriteNullBehaviorToXml(fNullBehavior, element); fRule.ToXml(element); }
/// <summary> /// Creates an returns a mappings filter from the specified XmlElement, or null if there is no filter defined /// </summary> /// <param name="node"></param> /// <returns></returns> internal static MappingsFilter Load(XmlElement node) { string filtVer = node.GetAttribute("sifVersion"); string filtDir = node.GetAttribute("direction"); if (filtVer.Length > 0 || filtDir.Length > 0) { MappingsFilter filt = new MappingsFilter(); if (filtVer.Length > 0) { filt.SifVersion = filtVer; } if (filtDir.Length > 0) { try { filt.Direction = (MappingDirection) Enum.Parse(typeof(MappingDirection), filtDir, true); } catch (Exception ex) { throw new AdkConfigException ("Field mapping rule specifies an unknown Direction flag: '" + filtDir + "'", ex); } } return(filt); } else { return(null); } }
/** * Creates a new FieldMapping instance and populates its properties from * the given XML Element * @param parent * @param element * @return a new FieldMapping instance * @throws ADKConfigException If the FieldMapping cannot read expected * values from the DOM Node */ public static FieldMapping FromXml( ObjectMapping parent, XmlElement element) { if (element == null) { throw new ArgumentException("Argument: 'element' cannot be null"); } String name = element.GetAttribute(ATTR_NAME); FieldMapping fm = new FieldMapping(); fm.SetNode(element); fm.FieldName = name; fm.DefaultValue = XmlUtils.GetAttributeValue(element, ATTR_DEFAULT); fm.Alias = XmlUtils.GetAttributeValue(element, ATTR_ALIAS); fm.ValueSetID = XmlUtils.GetAttributeValue(element, ATTR_VALUESET); String ifNullBehavior = element.GetAttribute(ATTR_IFNULL); if (ifNullBehavior.Length > 0) { if (String.Compare(ifNullBehavior, "default", true) == 0) { fm.NullBehavior = MappingBehavior.IfNullDefault; } else if (String.Compare(ifNullBehavior, "suppress", true) == 0) { fm.NullBehavior = MappingBehavior.IfNullSuppress; } } String dataType = element.GetAttribute(ATTR_DATATYPE); if (dataType != null && dataType.Length > 0) { try { fm.DataType = (SifDataType)Enum.Parse(typeof(SifDataType), dataType, true); } catch (FormatException iae) { Adk.Log.Warn("Unable to parse datatype '" + dataType + "' for field " + name, iae); } } String filtVer = element.GetAttribute(ATTR_SIFVERSION); String filtDir = element.GetAttribute(ATTR_DIRECTION); if (!(String.IsNullOrEmpty(filtVer)) || !(String.IsNullOrEmpty(filtDir))) { MappingsFilter filt = new MappingsFilter(); if (!String.IsNullOrEmpty(filtVer)) { filt.SifVersion = filtVer; } if (!String.IsNullOrEmpty(filtDir)) { if (String.Compare(filtDir, "inbound", true) == 0) { filt.Direction = MappingDirection.Inbound; } else if (String.Compare(filtDir, "outbound", true) == 0) { filt.Direction = MappingDirection.Outbound; } else { throw new AdkConfigException( "Field mapping rule for " + parent.ObjectType + "." + fm.FieldName + " specifies an unknown Direction flag: '" + filtDir + "'"); } } fm.Filter = filt; } // FieldMapping must either have node text or an <otherid> child XmlElement otherIdNode = XmlUtils.GetFirstElementIgnoreCase(element, "otherid"); if (otherIdNode == null) { String def = element.InnerText; if (def != null) { fm.SetRule(def); } else { fm.SetRule(""); } } else { fm.SetRule(OtherIdMapping.FromXml(parent, fm, otherIdNode), otherIdNode); } return(fm); }
/// <summary> /// Persists this mapping filter to the specified XmlElement /// </summary> /// <param name="filter">The filter to save</param> /// <param name="element"></param> internal static void Save(MappingsFilter filter, XmlElement element) { if (filter != null && filter.HasVersionFilter) { element.SetAttribute("sifVersion", filter.SifVersion); } else { element.RemoveAttribute("sifVersion"); } if (filter != null && filter.HasDirectionFilter) { element.SetAttribute("direction", filter.Direction.ToString("G")); switch (filter.Direction) { case MappingDirection.Inbound: element.SetAttribute("direction", "inbound"); break; case MappingDirection.Outbound: element.SetAttribute("direction", "outbound"); break; } } else { element.RemoveAttribute("direction"); } }
/// <summary> /// Creates an returns a mappings filter from the specified XmlElement, or null if there is no filter defined /// </summary> /// <param name="node"></param> /// <returns></returns> internal static MappingsFilter Load(XmlElement node) { string filtVer = node.GetAttribute("sifVersion"); string filtDir = node.GetAttribute("direction"); if (filtVer.Length > 0 || filtDir.Length > 0) { MappingsFilter filt = new MappingsFilter(); if (filtVer.Length > 0) { filt.SifVersion = filtVer; } if (filtDir.Length > 0) { try { filt.Direction = (MappingDirection) Enum.Parse(typeof (MappingDirection), filtDir, true); } catch (Exception ex) { throw new AdkConfigException ("Field mapping rule specifies an unknown Direction flag: '" + filtDir + "'", ex); } } return filt; } else { return null; } }
/** * Creates a set of mappings that operations can be applied to, such as * saving to a DOM or Agent.cfg. The results can be asserted by calling * {@see #assertMappings(Mappings)}. * * NOTE: This method returns an AgentConfig instance instead of a mappings * instance because there is no way set the Mappings instance on * AgentConfig. This might change in the future * * @return */ private AgentConfig createMappings() { Mappings root = fCfg.Mappings; // Remove the mappings being used root.RemoveChild( root.GetMappings( "Default" ) ); root.RemoveChild( root.GetMappings( "TestID" ) ); Mappings newMappings = root.CreateChild( "Test" ); // Add an object mapping ObjectMapping objMap = new ObjectMapping( "StudentPersonal" ); // Currently, the Adk code requires that an Object Mapping be added // to it's parent before fields are added. // We should re-examine this and perhaps fix it, if possible newMappings.AddRules( objMap ); objMap.AddRule( new FieldMapping( "FIELD1", "Name/FirstName" ) ); // Field 2 FieldMapping field2 = new FieldMapping( "FIELD2", "Name/LastName" ); field2.ValueSetID = "VS1"; field2.Alias = "ALIAS1"; field2.DefaultValue = "DEFAULT1"; MappingsFilter mf = new MappingsFilter(); mf.Direction = MappingDirection.Inbound; mf.SifVersion = SifVersion.SIF11.ToString(); field2.Filter = mf; objMap.AddRule( field2 ); // Field 3 test setting the XML values after it's been added to the // parent object (the code paths are different) FieldMapping field3 = new FieldMapping( "FIELD3", "Name/MiddleName" ); objMap.AddRule( field3 ); field3.ValueSetID = "VS2"; field3.Alias = "ALIAS2"; field3.DefaultValue = "DEFAULT2"; MappingsFilter mf2 = new MappingsFilter(); mf2.Direction = MappingDirection.Outbound; mf2.SifVersion = SifVersion.SIF15r1.ToString(); field3.Filter = mf2; field3.NullBehavior = MappingBehavior.IfNullDefault; OtherIdMapping oim = new OtherIdMapping( "ZZ", "BUSROUTE" ); FieldMapping field4 = new FieldMapping( "FIELD4", oim ); objMap.AddRule( field4 ); field4.DefaultValue = "Default"; field4.ValueSetID = "vs"; field4.Alias = "alias"; field4.DefaultValue = null; field4.ValueSetID = null; field4.Alias = null; field4.NullBehavior = MappingBehavior.IfNullSuppress; // Field4 tests the new datatype attribute FieldMapping field5 = new FieldMapping( "FIELD5", "Demographics/BirthDate" ); objMap.AddRule( field5 ); field5.DataType = SifDataType.Date; // Add a valueset translation ValueSet vs = new ValueSet( "VS1" ); newMappings.AddValueSet( vs ); // Add a few definitions for ( int a = 0; a < 10; a++ ) { vs.Define( "Value" + a, "SifValue" + a, "Title" + a ); } vs.Define( "AppDefault", "0000", "Default App Value" ); vs.SetAppDefault( "AppDefault", true ); vs.Define( "0000", "SifDefault", "Default Sif Value" ); vs.SetSifDefault( "SifDefault", false ); // Add a valueset translation vs = new ValueSet( "VS2" ); newMappings.AddValueSet( vs ); // Add a few definitions for ( int a = 0; a < 3; a++ ) { vs.Define( "q" + a, "w" + a, "t" + a ); } vs.Define( "AppDefault", "0000", "Default Value" ); vs.SetAppDefault( "AppDefault", true ); vs.SetSifDefault( "0000", true ); return fCfg; }