public static OtherIdMapping FromXml(ObjectMapping parent, FieldMapping field, XmlElement element) { // The OtherId type= attribute is required String type = element.GetAttribute("type"); if (type == null) { type = element.GetAttribute("Type"); } if (type == null) { throw new AdkConfigException("Field mapping rule " + parent.ObjectType + "." + field.FieldName + " specifies an <OtherId> without a 'type' attribute"); } // The OtherId prefix= attribute is required String prefix = element.GetAttribute("prefix"); if (prefix == null) { prefix = element.GetAttribute("Prefix"); } if (prefix == null) { throw new AdkConfigException("Field mapping rule " + parent.ObjectType + "." + field.FieldName + " specifies an <OtherId> without a 'prefix' attribute"); } // Create a new OtherIdMapping as a child of the FieldMapping OtherIdMapping id = new OtherIdMapping(type, prefix, element); return(id); }
/// <summary> Return an array of all FieldMapping definitions</summary> /// <param name="inherit">True to inherit FieldMapping definitions from the /// parent Mappings ancestry /// </param> public IList <FieldMapping> GetRulesList(bool inherit) { List <FieldMapping> rules = new List <FieldMapping>(); if (inherit) { IDictionary <String, Object> set = new Dictionary <String, Object>(); // Keep the rules in a list because the ordering of // rules is important Mappings m = fParent; while (m != null) { ObjectMapping om = m.GetRules(fObjType, false); if (om != null && om.fFieldRules != null) { foreach (FieldMapping fm in om.fFieldRules) { String key = fm.Key; if (!set.ContainsKey(key)) { set.Add(key, null); rules.Add(fm); } } } m = m.fParent; } } else if (fFieldRules != null) { rules.AddRange(fFieldRules); } return(rules); }
/// <summary> Creates a copy this ObjectMapping instance. /// /// This method performs a "deep copy", such that a clone is made of each /// child FieldMapping. The parent of the new ObjectMapping will be the /// Mappings object passed to this function. Any DOM Nodes assigned to this /// object or its children are cloned and appended to the parent Mappings's /// DOM XmlElement if one exists. /// /// </summary> /// <returns> A "deep copy" of this object /// </returns> public ObjectMapping Copy(Mappings newParent) { // Create a new ObjectMapping instance ObjectMapping m = new ObjectMapping(fObjType); // Copy the DOM XmlElement if (fNode != null) { if (newParent.fNode != null) { XmlElement newNode = (XmlElement)newParent.fNode.OwnerDocument.ImportNode(fNode, false); newParent.fNode.AppendChild(newNode); m.fNode = newNode; } } // Copy fFieldRules if (fFieldRules != null) { if (m.fFieldRules == null) { m.fFieldRules = new List <FieldMapping>(); } for (int i = 0; i < fFieldRules.Count; i++) { FieldMapping copy = (fFieldRules[i]).Copy(m); m.AddRule(copy); } } return(m); }
public void testCreateMappings() { // Create the root instance Mappings root = new Mappings(); // Create the default set of universal mappings Mappings defaults = new Mappings( root, "Default" ); root.AddChild( defaults ); // Create an ObjectMapping for StudentPersonal ObjectMapping studentMappings = new ObjectMapping( "StudentPersonal" ); defaults.AddRules( studentMappings ); // Add field rules studentMappings.AddRule( new FieldMapping( "FIRSTNAME", "Name[@Type='04']/FirstName" ) ); studentMappings.AddRule( new FieldMapping( "LASTNAME", "Name[@Type='04']/LastName" ) ); // Create a set of mappings for the state of Wisconsin Mappings wisconsin = new Mappings( defaults, "Wisconsin" ); defaults.AddChild( wisconsin ); // Create a set of mappings for the Neillsville School District Mappings neillsville = new Mappings( wisconsin, "Neillsville" ); wisconsin.AddChild( neillsville ); XmlDocument doc = new XmlDocument( ); doc.LoadXml( "<agent/>"); XmlElement n = root.ToDom( doc ); debug( doc ); }
/** * Creates a MappingsContext instance to handle a set of mappings operations using * the same parameters * @param m The mappings instance to use * @param direction The mappings direction * @param version The version of SIF to use for evaluating rule filters on field mappings * @param elementDef The ElementDef representing the object type being mapped * @return A new MappingsContext, initialized to map using the specified parameters */ public static MappingsContext Create(Mappings m, MappingDirection direction, SifVersion version, IElementDef elementDef) { // Get the rules associated with the element type MappingsContext mc = new MappingsContext(m, direction, version, elementDef); ObjectMapping om = m.GetRules(elementDef.Name, true); mc.AddRules(om); return(mc); }
private void AddRules(ObjectMapping om) { // Get the rules associated with the element type fObjectMappings = om; if (om != null) { foreach (FieldMapping fm in om.GetRulesList(true)) { // addRule( FieldMapping ) will automatically filter out // any rules that need to be filtered AddRule(fm); } } }
/// <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); }
/** * 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); }
/** * 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; }
/// <summary> Creates a copy this ObjectMapping instance. /// /// This method performs a "deep copy", such that a clone is made of each /// child FieldMapping. The parent of the new ObjectMapping will be the /// Mappings object passed to this function. Any DOM Nodes assigned to this /// object or its children are cloned and appended to the parent Mappings's /// DOM XmlElement if one exists. /// /// </summary> /// <returns> A "deep copy" of this object /// </returns> public ObjectMapping Copy(Mappings newParent) { // Create a new ObjectMapping instance ObjectMapping m = new ObjectMapping(fObjType); // Copy the DOM XmlElement if (fNode != null) { if (newParent.fNode != null) { XmlElement newNode = (XmlElement) newParent.fNode.OwnerDocument.ImportNode( fNode, false ); newParent.fNode.AppendChild( newNode ); m.fNode = newNode; } } // Copy fFieldRules if (fFieldRules != null) { if (m.fFieldRules == null) { m.fFieldRules = new List<FieldMapping>(); } for (int i = 0; i < fFieldRules.Count; i++) { FieldMapping copy = (fFieldRules[i]).Copy(m); m.AddRule(copy); } } return m; }
/// <summary> Add an ObjectMapping definition to this Mappings instance</summary> protected internal void AddRules(ObjectMapping om, bool buildDomTree) { if (om.fParent != null) { throw new SystemException ("ObjectMapping is already a child of a Mappings instance"); } om.fParent = this; if (fObjRules == null) { fObjRules = new Dictionary<String, ObjectMapping>(); } fObjRules[om.ObjectType] = om; if (om.fNode == null && buildDomTree && fNode != null) { om.fNode = fNode.OwnerDocument.CreateElement(XML_OBJECT); if (om.ObjectType != null) { om.fNode.SetAttribute("object", om.ObjectType); } fNode.AppendChild(om.fNode); } }
/// <summary> Remove an ObjectMapping definition from this Mappings instance</summary> public void RemoveRules(ObjectMapping om) { if (fObjRules != null) { if (fNode != null && om.fNode != null) { fNode.RemoveChild(om.fNode); } fObjRules.Remove(om.ObjectType); } }
protected internal void Populate(XmlElement node, Mappings parent) { // TODO: We should probably be using a GetElementsby name query here // I think the java implementation might have been doing a recursive search here foreach (XmlElement n in new XmlUtils.XmlElementEnumerator(node)) { if (n.Name.ToUpper() == XML_MAPPINGS.ToUpper()) { // Get the ID string id = n.GetAttribute("id"); // Create a new child Mappings object Mappings mappings = new Mappings(parent, id); mappings.XmlElement = n; if (parent.fChildren == null) { parent.fChildren = new Dictionary<String, Mappings>(); } parent.fChildren[mappings.Id] = mappings; // Set a SifVersion filter if present string ver = n.GetAttribute("sifVersion"); if (ver.Trim().Length > 0) { mappings.SetSIFVersionFilter(ver); } // Set a ZoneId filter if present string zoneIds = n.GetAttribute("zoneId"); if (zoneIds.Trim().Length > 0) { mappings.SetZoneIdFilter(zoneIds); } // Set a SourceId filter if present string sourceIds = n.GetAttribute("sourceId"); if (sourceIds.Trim().Length > 0) { mappings.SetSourceIdFilter(sourceIds); } // Populate the Mappings object with rules Populate(n, mappings); } else { if (n.Name.ToUpper() == XML_OBJECT.ToUpper()) { if (n.ParentNode.Name == XML_MAPPINGS) { string obj = n.GetAttribute(XML_OBJECT); if (obj == null) { throw new AdkConfigException ("<object> element must have an object attribute"); } ObjectMapping om = new ObjectMapping(obj); om.XmlElement = n; parent.AddRules(om, false); PopulateObject(n, om); } } else { if (n.Name.ToUpper() == "PROPERTY") { if (n.ParentNode.Name == XML_MAPPINGS) { parent.SetProperty (n.GetAttribute(AdkXmlConstants.Property.NAME), n.GetAttribute(AdkXmlConstants.Property.VALUE)); } } else { if (n.Name.ToUpper() == "VALUESET") { if (n.ParentNode.Name == XML_MAPPINGS) { ValueSet set_Renamed = new ValueSet (n.GetAttribute("id"), n.GetAttribute("title"), n); parent.AddValueSet(set_Renamed); PopulateValueSet(n, set_Renamed); } } else { Populate(n, parent); } } } } } }
private Mappings buildMappings1() { // root Mappings root = new Mappings(); // root.Default Mappings defaults = new Mappings( root, "Default", null, null, null ); root.AddChild( defaults ); // root.Default.StudentPersonal ObjectMapping studentMappings = new ObjectMapping( "StudentPersonal" ); defaults.AddRules( studentMappings ); studentMappings.AddRule( new FieldMapping( "REFID", "@RefId" ) ); // root.Default.MA Mappings massachusetts = new Mappings( defaults, "MA", null, null, null ); defaults.AddChild( massachusetts ); // root.Default.MA.StudentPersonal studentMappings = new ObjectMapping( "StudentPersonal" ); massachusetts.AddRules( studentMappings ); studentMappings.AddRule( new FieldMapping( "LOCALID", "LocalId" ) ); studentMappings.AddRule( new FieldMapping( "FIRSTNAME", "Name[@Type='01']/FirstName" ) ); studentMappings.AddRule( new FieldMapping( "LASTNAME", "Name[@Type='01']/LastName" ) ); // root.Default.MA.Boston Mappings boston = new Mappings( massachusetts, "Boston", null, "Boston", null ); massachusetts.AddChild( boston ); // root.Default.MA.Boston.StudentPersonal studentMappings = new ObjectMapping( "StudentPersonal" ); boston.AddRules( studentMappings ); studentMappings.AddRule( new FieldMapping( "BIRTHDAY", "Demographics/BirthDate" ) ); return root; }
/// <summary> Parse the <c><field></c> children of an <c><object></c> element. /// /// </summary> /// <param name="element">A DOM <i>XmlElement</i> encapsulating an <c><object></c> element /// </param> /// <param name="parent">The parent ObjectMapping instance /// </param> protected internal void PopulateObject(XmlElement element, ObjectMapping parent) { foreach (XmlElement n in new XmlUtils.XmlElementEnumerator(element)) { if (n.Name.ToUpper() == XML_FIELD.ToUpper()) { FieldMapping fm = FieldMapping.FromXml( parent, n ); parent.AddRule( fm, false ); } } }
private IList<FieldMapping> GetRulesList(ObjectMapping om, SifVersion version, MappingDirection direction) { IList<FieldMapping> list = om.GetRulesList(true); // Remove any items that should be filtered out for (int a = list.Count - 1; a > -1; a--) { MappingsFilter filt = list[a].Filter; // Filter out this rule? if (filt != null) { if (!filt.EvalDirection(direction) || !filt.EvalVersion(version)) { list.RemoveAt(a); } } } return list; }
public static OtherIdMapping FromXml(ObjectMapping parent, FieldMapping field, XmlElement element) { // The OtherId type= attribute is required String type = element.GetAttribute("type"); if (type == null) type = element.GetAttribute("Type"); if (type == null) throw new AdkConfigException("Field mapping rule " + parent.ObjectType + "." + field.FieldName + " specifies an <OtherId> without a 'type' attribute"); // The OtherId prefix= attribute is required String prefix = element.GetAttribute("prefix"); if (prefix == null) prefix = element.GetAttribute("Prefix"); if (prefix == null) throw new AdkConfigException("Field mapping rule " + parent.ObjectType + "." + field.FieldName + " specifies an <OtherId> without a 'prefix' attribute"); // Create a new OtherIdMapping as a child of the FieldMapping OtherIdMapping id = new OtherIdMapping(type, prefix, element); return id; }
/// <summary> Gets all ObjectMappings defined for this Mappings instance, optionally /// including those inherited by its parents. /// </summary> /// <returns> An array of all ObjectMappings /// </returns> public ObjectMapping[] GetObjectMappings(bool inherit) { Hashtable hashSet = new Hashtable(); Mappings m = this; while (m != null) { if (m.fObjRules != null) { foreach (ObjectMapping om in m.fObjRules.Values) { if (!hashSet.ContainsKey(om.ObjectType)) { hashSet[om.ObjectType] = om; } } } if (inherit) { m = m.fParent; } else { m = null; } } ObjectMapping[] arr = new ObjectMapping[hashSet.Count]; hashSet.Values.CopyTo(arr, 0); return arr; }
/// <summary> Add an ObjectMapping definition to this Mappings instance</summary> public void AddRules(ObjectMapping om) { AddRules(om, true); }