protected StudentPersonal mapToStudentPersonal(IFieldAdaptor adaptor, String cfg, IValueBuilder vb) { StudentPersonal sp = new StudentPersonal(); doOutboundMapping(adaptor, sp, cfg, vb); return(sp); }
/// <summary>Sets an element or attribute value identified by an XPath-like query string.</summary> /// <remarks> /// NOTE: This method makes calls to SIFXPathContext. If multiple calls to /// <c>setElementOrAttribute</c> are being done, it is much more efficient to create /// a new <c>SifXPathContext</c> by calling <c>SifXPathContext.NewInstance(sdo)</c> and then /// calling <c>.SetElementorAttributeon</c> on that SifXPathContext instance /// </remarks> /// <param name="xpath">An XPath-like query string that identifies the element or /// attribute to set. The string must reference elements and attributes /// by their <i>version-independent</i> names. /// </param> /// <param name="valu">The value to assign to the element or attribute if the /// query string does not set a value; may be null /// </param> /// <param name="adaptor"> A data source may be used for variable /// substitutions within the query string /// </param> public virtual void SetElementOrAttribute(string xpath, string valu, IFieldAdaptor adaptor) { SifVersion = Adk.SifVersion; SifXPathContext spc = SifXPathContext.NewSIFContext(this); if (adaptor is IXPathVariableLibrary) { spc.AddVariables("", (IXPathVariableLibrary)adaptor); } spc.SetElementOrAttribute(xpath, valu); }
/** * Perform a mapping operation on the specified SIFElement. The mapping operation * will be either inbound or outbound, depending on whether this class was returned * from {@link Mappings#selectInbound(ElementDef, SIFVersion, String, String)} or * {@link Mappings#selectOutbound(ElementDef, SIFVersion, String, String)} * @param mappedElement The SIFElement to perform the mappings operation on * @param adaptor The FieldAdaptor to use for getting or setting data * @throws ADKMappingException */ public void Map(SifElement mappedElement, IFieldAdaptor adaptor) { SifXPathContext context = GetXPathContext(mappedElement, adaptor); if (fDirection == MappingDirection.Inbound) { fMappings.MapInbound(context, adaptor, mappedElement, fFieldMappings, fSIFVersion); } else if (fDirection == MappingDirection.Outbound) { fMappings.MapOutbound(context, adaptor, mappedElement, fFieldMappings, fValueBuilder, fSIFVersion); } }
public void testStudentContactMapping010() { StudentContact sc = new StudentContact(); Mappings mappings = fCfg.Mappings.GetMappings("Default"); IFieldAdaptor adaptor = createStudentContactFields(); mappings.MapOutbound(adaptor, sc); SifWriter writer = new SifWriter(Console.Out); writer.Write(sc); writer.Flush(); Assertion.AssertEquals("Testing Pickup Rights", "Yes", sc.ContactFlags.PickupRights); }
protected StudentPersonal doOutboundMappingSelect(IFieldAdaptor adaptor, String cfg, String zoneId, String sourceId, SifVersion version) { AgentConfig config = createConfig(cfg); Mappings root = config.Mappings; Mappings defMap = root.GetMappings("Default"); Mappings selectedMap = defMap.Select(zoneId, sourceId, version); StudentPersonal sp = new StudentPersonal(); selectedMap.MapOutbound(adaptor, sp); Console.WriteLine(sp.ToXml()); return(sp); }
/// <summary> Replaces all <c>$(variable)</c> tokens in the source string with /// the corresponding entry in the supplied Map /// </summary> /// <param name="src">The source string /// </param> /// <param name="data">The field adaptor to use /// </param> public static string ReplaceTokens(string src, IFieldAdaptor data) { if (src == null) { return(null); } StringBuilder b = new StringBuilder(); int len = src.Length; int at = 0; int mark = 0; do { at = src.IndexOf("$(", at); if (at == -1) { at = len; } b.Append(src.Substring(mark, (at - mark))); if (at < len) { int i = src.IndexOf(")", at + 2); if (i != -1) { mark = i + 1; string key = src.Substring(at + 2, i - (at + 2)); at = mark; object val = data.GetValue(key); if (val != null) { b.Append(val); } } else { b.Append(src.Substring(mark, (len - mark))); at = len; } } }while (at < len); return(b.ToString()); }
protected void doOutboundMapping(IFieldAdaptor adaptor, SifDataObject sdo, String cfg, IValueBuilder vb) { AgentConfig config = createConfig(cfg); Mappings root = config.Mappings; Mappings defMap = root.GetMappings("Default"); if (vb != null) { defMap.MapOutbound(adaptor, sdo, vb); } else { defMap.MapOutbound(adaptor, sdo); } Console.WriteLine(sdo.ToXml()); }
private SifXPathContext GetXPathContext( SifElement mappedElement, IFieldAdaptor adaptor) { lock (this) { if (!mappedElement.ElementDef.Name.Equals(fElementDef.Name)) { throw new AdkMappingException( "Unable to use object for mapping. MappingsContext expected an object of type '" + fElementDef.Name + "' but was '" + mappedElement.ElementDef.Name + "'.", null); } if (fRootContext == null) { fRootContext = SifXPathContext.NewSIFContext(mappedElement, fSIFVersion); if (adaptor is IXPathVariableLibrary) { fRootContext.AddVariables("", (IXPathVariableLibrary)adaptor); } } return(SifXPathContext.NewSIFContext(fRootContext, mappedElement)); } }
/// <summary> Constructor</summary> public DefaultValueBuilder(IFieldAdaptor data) : this(data, Adk.TextFormatter) { }
/// <summary> /// Constructor called by the ADK. Set the <seealso cref="Edustructures.SifWorks.DefaultValueBuilder.DefaultClass">DefaultClass</seealso> property here so the ADK can find your macro method to call. /// </summary> /// <param name="data"></param> public DataUtilMacro(IFieldAdaptor data) : base(data) { DefaultClass = typeof(DataUtilMacro).AssemblyQualifiedName; }
/// <summary> Produce a table of field values from a SIF Data Object. /// /// This <c>map</c> method populates the supplied IDictionary with element /// or attribute values from the SifDataObject by evaluating all field rules /// defined by this Mappings object for the associated SIF Data Object type. /// Field rules are only evaluated if no entry currently exists in the /// IDictionary. Consequently, the caller may pre-load the IDictionary with known /// field values if possible and they will not be overridden by the mapping /// process. /// /// /// This method is intended to obtain element and attribute values from a /// SifDataObject <i>consumed</i> by the agent when processing SIF /// Events or SIF Responses. In contrast, the other form of the <c>map</c> /// method is intended to populate a new SifDataObject instance when an /// agent is <i>publishing</i> objects to a zone. /// /// /// To use this method, /// /// <ol> /// <item><term> /// Create a IDictionary and optionally populate it with known field /// values that will not be subject to the mapping process. If pre-loading /// the IDictionary, the key of each entry should be the local /// application-defined field name and the value should be the string /// value of that field. Any field added to the IDictionary before calling /// this method will not be subject to mapping rules. /// </term></item> /// <item><term> /// Call this <c>map</c> method, passing the SifDataObject /// instance to retrieve field values from for insertion into the /// IDictionary. The method first looks up the ObjectMapping instance /// corresponding to the SIF Data Object type. If no ObjectMapping /// has been defined for the object type, no action is taken and the /// method returns successfully without exception. Otherwise, all /// field rules defined by the ObjectMapping are evaluated in order. /// If a rule evaluates successfully, the corresponding element or /// attribute value will be inserted into the IDictionary. A rule will /// not be evaluated if the associated field already exists in the /// IDictionary. /// </term></item> /// </ol> /// /// </summary> /// <param name="dataObject">The SifDataObject from which to retrieve element and /// attribute values from when performing the mapping operation. /// /// </param> /// <param name="results">A IDictionary to receive the results of the mapping, where /// each entry in the map is keyed by the local application-defined name /// of a field and the value is the text value of the corresponding /// element or attribute in the SifDataObject. /// /// </param> /// <exception cref="AdkMappingException"> thrown if an error occurs while evaluating /// a field rule /// </exception> public void MapInbound(SifDataObject dataObject, IFieldAdaptor results) { MapInbound(dataObject, results, Adk.SifVersion); }
/// <summary>Sets an element or attribute value identified by an XPath-like query string.</summary> /// <remarks> /// NOTE: This method makes calls to SIFXPathContext. If multiple calls to /// <c>setElementOrAttribute</c> are being done, it is much more efficient to create /// a new <c>SifXPathContext</c> by calling <c>SifXPathContext.NewInstance(sdo)</c> and then /// calling <c>.SetElementorAttributeon</c> on that SifXPathContext instance /// </remarks> /// <param name="xpath">An XPath-like query string that identifies the element or /// attribute to set. The string must reference elements and attributes /// by their <i>version-independent</i> names. /// </param> /// <param name="valu">The value to assign to the element or attribute if the /// query string does not set a value; may be null /// </param> /// <param name="adaptor"> A data source may be used for variable /// substitutions within the query string /// </param> public virtual void SetElementOrAttribute( string xpath, string valu, IFieldAdaptor adaptor ) { SifVersion = Adk.SifVersion; SifXPathContext spc = SifXPathContext.NewSIFContext( this ); if ( adaptor is IXPathVariableLibrary ) { spc.AddVariables( "", (IXPathVariableLibrary) adaptor ); } spc.SetElementOrAttribute( xpath, valu ); }
public TestValueBuilder( IFieldAdaptor data ) : base(data) { }
private SifXPathContext GetXPathContext( SifElement mappedElement, IFieldAdaptor adaptor) { lock (this) { if (!mappedElement.ElementDef.Name.Equals(fElementDef.Name)) { throw new AdkMappingException( "Unable to use object for mapping. MappingsContext expected an object of type '" + fElementDef.Name + "' but was '" + mappedElement.ElementDef.Name + "'.", null); } if (fRootContext == null) { fRootContext = SifXPathContext.NewSIFContext(mappedElement, fSIFVersion); if (adaptor is IXPathVariableLibrary) { fRootContext.AddVariables( "", (IXPathVariableLibrary)adaptor); } } return SifXPathContext.NewSIFContext(fRootContext, mappedElement); } }
/// <summary> Populate a SifDataObject from values in the supplied IDictionary. /// /// This form of the <c>map</c> method that accepts a custom /// <c>ValueBuilder</c> implementation to evaluate value expressions /// in XPath-like query strings. The <c>map</c> method uses the /// DefaultValueBuilder class as its built-in implementation, but you can /// supply your own by calling this method instead. /// /// </summary> /// <param name="adaptor">An IFieldAdaptor that contains field values to assign to the /// supplied SifDataObject, where each entry in the map is keyed by the /// local application-defined name of a field and the value is the text /// value to assign to the corresponding element or attribute of the /// SifDataObject. /// /// </param> /// <param name="adaptor">An IFieldAdaptor containing field values</param> /// <param name="data">The SifDataObject to assign field values to /// /// </param> /// <param name="valueBuilder">A custom ValueBuilder implementation to evaluate /// value expressions in XPath-like query strings /// /// </param> /// <exception cref="AdkMappingException"> thrown if an error occurs while /// evaluating a field rule /// </exception> public void MapOutbound(IFieldAdaptor adaptor, SifDataObject data, IValueBuilder valueBuilder) { MapOutbound(adaptor, data, valueBuilder, Adk.SifVersion); }
/// <summary> /// Populate a SifDataObject from values in the supplied IDictionary. /// </summary> /// <param name="adaptor">An IFieldAdaptor that contains field values to assign to the /// supplied SifDataObject, where each entry in the map is keyed by the /// local application-defined name of a field and the value is the text /// value to assign to the corresponding element or attribute of the /// SifDataObject.</param> /// <param name="dataObject">The SifDataObject to assign field values to</param> /// <param name="version">The SifVersion associated with the mapping operation. /// For inbound SIF_Event and SIF_Response messages, this value should /// be obtained by calling <c>getSIFVersion</c> on the /// <i>SifMessageInfo</i> parameter passed to the message handler. For /// inbound SIF_Request messages, it should be obtained by calling the /// <c>SifMessageInfo.getSIFRequestVersion</c> method. For /// outbound messages, this value should be obtained by calling /// <c>Adk.getSIFVersion</c> to get the version of SIF the class /// framework was initialized with. Note when this parameter is /// <c>null</c>, no SIF Version filtering will be applied to /// field mapping rules.</param> public void MapOutbound(IFieldAdaptor adaptor, SifDataObject dataObject, SifVersion version) { MapOutbound(adaptor, dataObject, new DefaultValueBuilder(adaptor), version); }
public TestValueBuilder(IFieldAdaptor data) : base(data) { }
internal void MapOutbound( SifXPathContext context, IFieldAdaptor adaptor, SifElement dataObject, ICollection<FieldMapping> fields, IValueBuilder valueBuilder, SifVersion version) { #if PROFILED if( BuildOptions.PROFILED ){ ProfilerUtils.profileStart( String.valueOf( com.OpenADK.sifprofiler.api.OIDs.ADK_OUTBOUND_TRANSFORMATIONS ), dataObject.getElementDef(), null ); } #endif SifFormatter textFormatter = Adk.TextFormatter; FieldMapping lastRule = null; try { foreach (FieldMapping fm in fields) { lastRule = fm; String fieldName = fm.Alias; if (fieldName == null) { fieldName = fm.FieldName; } if (fieldName == null || fieldName.Length == 0) { throw new AdkMappingException( "Mapping rule for " + dataObject.ElementDef.Name + "[" + fm.FieldName + "] must specify a field name", null); } if (adaptor.HasField(fieldName) || fm.HasDefaultValue) { // // For outbound mapping operations, only process // XPathRules. All other rule types, like OtherIdRule, // are only intended to be used for inbound mappings. // if (fm.fRule is XPathRule) { XPathRule rule = (XPathRule) fm.fRule; // Lookup or create the element/attribute referenced by the rule String ruledef = rule.XPath; if (ruledef == null || ruledef.Trim().Length == 0) { throw new AdkMappingException( "Mapping rule for " + dataObject.ElementDef.Name + "[\"" + fieldName + "\"] must specify a path to an element or attribute", null); } // TT 199 If the FieldMapping has an "ifnull" value of "suppress", // don't render a result // Determine if this element should be created before attempting to create it // If the value resolves to null and the IFNULL_SUPPRESS flag is set, the element // should not be created. That's why we have to look up the ElementDef first TypeConverter typeConverter = null; IElementDef def = rule.LookupTargetDef(dataObject.ElementDef); if (def != null) { typeConverter = def.TypeConverter; } if (typeConverter == null) { typeConverter = SifTypeConverters.STRING; // TODO: Perhaps the following exception should be thrown when // in STRICT mode // throw new ADKMappingException( "Element {" + def.name() + // "} from rule \"" + ruledef + "\" does not have a data type definition.", null ); } SifSimpleType mappedValue; mappedValue = adaptor.GetSifValue(fieldName, typeConverter, fm); // Perform a valueset translation, if applicable if (mappedValue != null && mappedValue is SifString && fm.ValueSetID != null) { String textValue = mappedValue.ToString(); // Perform automatic ValueSet translation ValueSet vs = GetValueSet(fm.ValueSetID, true); if (vs != null) { // TT 199. Perform a more detailed valueset translation. // If there is a default value for this field, use it if there is // no match found in the value set textValue = vs.Translate(textValue, fm.DefaultValue); } mappedValue = new SifString(textValue); } bool usedDefault = false; if (mappedValue == null || mappedValue.RawValue == null) { // If the FieldMapping has a Default value, use that, unless // it is explicitly suppressed if (fm.NullBehavior != MappingBehavior.IfNullSuppress && fm.HasDefaultValue) { mappedValue = fm.GetDefaultValue(typeConverter, textFormatter); usedDefault = true; } else { continue; } } if (!usedDefault) { String valueExpression = rule.ValueExpression; if (valueExpression != null) { // This XPath rule has a value assignment expression at the end of it String value = valueBuilder.Evaluate(valueExpression); mappedValue = typeConverter.Parse(textFormatter, value); } } // If we have a null value to assign at this point, move on to the next rule if (mappedValue == null || mappedValue.RawValue == null) { continue; } // At this point, mappedValue should not be null. We are committeed // to building out the path and setting the value. INodePointer pointer = rule.CreatePath(context, version); // If the element/attribute does not have a value, assign one. // If it does have a value, it was already assigned by the XPath // rule in the lookupByXPath method above and should not be // changed. // if (pointer != null) { Element pointedElement = (Element) pointer.Value; SifSimpleType elementValue = pointedElement.SifValue; if (elementValue == null || elementValue.RawValue == null) { if (mappedValue is SifString) { // Now that we have the actual element, we may need to create convert the // data if we were unable to resolve the TypeConverter above. This only happens // in cases involving surrogates where the rule.lookupTargetDef( dataObject.getElementDef() ); // fails to find the target ElementDef TypeConverter converter = pointedElement.ElementDef.TypeConverter; if (converter != null && converter.DataType != mappedValue.DataType) { mappedValue = converter.Parse(textFormatter, mappedValue.ToString()); } } // This check for null should really not be necessary, // however keepingit in for now if (mappedValue != null) { pointedElement.SifValue = mappedValue; } } } } } } } catch (Exception e) { if (lastRule != null) { throw new AdkMappingException( "Unable to evaluate field rule: " + lastRule.fRule + " : " + e.Message, null, e); } throw new AdkMappingException(e.ToString(), null, e); } #if PROFILED finally { if( BuildOptions.PROFILED ) ProfilerUtils.profileStop(); } #endif }
internal void MapInbound( SifXPathContext xpathContext, IFieldAdaptor results, SifElement inboundObject, ICollection<FieldMapping> fields, SifVersion version) { #if PROFILED if( BuildOptions.PROFILED ){ ProfilerUtils.profileStart( String.valueOf( com.OpenADK.sifprofiler.api.OIDs.ADK_INBOUND_TRANSFORMATIONS ), inboundObject.getElementDef(), null ); } #endif FieldMapping lastRule = null; try { foreach (FieldMapping rule in fields) { lastRule = rule; if (!results.HasField(rule.FieldName)) { SifSimpleType val = rule.Evaluate(xpathContext, version, true); if (val != null) { if (rule.ValueSetID != null && val is SifString) { String currentValue = val.ToString(); // Perform automatic ValueSet translation // TT 199. Perform a more detailed valueset translation. // If there is a default value set, use it if there is // no match found in the value set ValueSet vs = GetValueSet(rule.ValueSetID, true); if (vs != null) { currentValue = vs.TranslateReverse(currentValue, rule.DefaultValue); } val = new SifString(currentValue); } results.SetSifValue(rule.FieldName, val, rule); } } } } catch (Exception e) { if (lastRule != null) { throw new AdkMappingException( "Unable to evaluate field rule: " + lastRule.fRule + " : " + e.Message, null, e); } throw new AdkMappingException(e.ToString(), null, e); } }
/// <summary> Populate a SifDataObject from values in the supplied IDictionary. /// /// This form of the <c>map</c> method allows the caller to specify /// whether it is performing an inbound or outbound mapping operation, /// as well as the version of SIF associated with the SIF Data Object /// that's being mapped. These values are used to filter field mapping rules. /// The direction flag is also used to invoke automatic ValueSet /// translations on fields that have a <i>ValueSet</i> attribute. /// /// </summary> /// <param name="adaptor">An IFieldAdaptor that contains field values to assign to the /// supplied SifDataObject, where each entry in the map is keyed by the /// local application-defined name of a field and the value is the text /// value to assign to the corresponding element or attribute of the /// SifDataObject. /// /// </param> /// <param name="dataObject">The SifDataObject to assign field values to /// /// </param> /// <param name="valueBuilder">A custom ValueBuilder implementation to evaluate /// value expressions in XPath-like query strings /// /// </param> /// <param name="version">The SifVersion associated with the mapping operation. /// For inbound SIF_Event and SIF_Response messages, this value should /// be obtained by calling <c>getSIFVersion</c> on the /// <i>SifMessageInfo</i> parameter passed to the message handler. For /// inbound SIF_Request messages, it should be obtained by calling the /// <c>SifMessageInfo.getSIFRequestVersion</c> method. For /// outbound messages, this value should be obtained by calling /// <c>Adk.getSIFVersion</c> to get the version of SIF the class /// framework was initialized with. Note when this parameter is /// <c>null</c>, no SIF Version filtering will be applied to /// field mapping rules. /// /// </param> /// <exception cref="AdkMappingException"> thrown if an error occurs while /// evaluating a field rule</exception> public void MapOutbound(IFieldAdaptor adaptor, SifDataObject dataObject, IValueBuilder valueBuilder, SifVersion version) { ObjectMapping om = GetRules(dataObject.ElementDef.Tag(version), true); if (om != null) { SifXPathContext xpathContext = SifXPathContext.NewSIFContext(dataObject, version); if (adaptor is IXPathVariableLibrary) { xpathContext.AddVariables("", (IXPathVariableLibrary) adaptor); } IList<FieldMapping> list = GetRulesList(om, version, MappingDirection.Outbound); MapOutbound(xpathContext, adaptor, dataObject, list, valueBuilder, version); } }
/// <summary> /// Creates an instance of DefaultValueBuilder that builds values based /// on the SIFDataMap, using the specified <c>SIFFormatter</c> instance /// </summary> /// <param name="data"></param> /// <param name="formatter"></param> public DefaultValueBuilder(IFieldAdaptor data, SifFormatter formatter) { fVars = data; fFormatter = formatter; }
/// <summary> Produce a table of field values from a SIF Data Object. /// /// This form of the <c>map</c> method allows the client to specify /// whether it is performing an inbound or outbound mapping operation. /// Currently, the direction flag is used to invoke automatic ValueSet /// translations on fields that have a <i>ValueSet</i> attribute. /// /// </summary> /// <param name="data">The SifDataObject from which to retrieve element and /// attribute values from when performing the mapping operation. /// /// </param> /// <param name="results">A IDictionary to receive the results of the mapping, where /// each entry in the map is keyed by the local application-defined name /// of a field and the value is the text value of the corresponding /// element or attribute in the SifDataObject.</param> /// <param name="version">The SifVersion associated with the mapping operation. /// For inbound SIF_Event and SIF_Response messages, this value should /// be obtained by calling <c>getSIFVersion</c> on the /// <i>SifMessageInfo</i> parameter passed to the message handler. For /// inbound SIF_Request messages, it should be obtained by calling the /// <c>SifMessageInfo.getSIFRequestVersion</c> method. For /// outbound messages, this value should be obtained by calling /// <c>Adk.getSIFVersion</c> to get the version of SIF the class /// framework was initialized with. Note when this parameter is /// <c>null</c>, no SIF Version filtering will be applied to /// field mapping rules. /// /// </param> /// <exception cref="AdkMappingException"> thrown if an error occurs while evaluating /// a field rule /// /// @since Adk 1.5 /// </exception> public void MapInbound(SifDataObject data, IFieldAdaptor results, SifVersion version) { ObjectMapping om = GetRules(data.ElementDef.Tag(data.SifVersion), true); if (om != null) { SifXPathContext xpathContext = SifXPathContext.NewSIFContext(data, version); if (results is IXPathVariableLibrary) { xpathContext.AddVariables("", (IXPathVariableLibrary) results); } IList<FieldMapping> list = GetRulesList(om, version, MappingDirection.Inbound); MapInbound(xpathContext, results, data, list, version); } }