private void SetDestinationAttributeValue(FlowRuleParameters parameters, IList <object> values, Attrib attribute)
{
if (attribute.IsMultivalued)
{
if (values.Count == 0)
{
attribute.Delete();
}
else
{
this.SetAttributeValues(values, attribute);
}
}
else
{
if (values.Count > 1)
{
throw new TooManyValuesException(parameters.TargetAttributeName);
}
else if (values.Count == 0)
{
attribute.Delete();
}
else
{
this.SetAttributeValue(values.First(), attribute);
}
}
}
private IList <object> GetSourceValuesForExport(FlowRuleParameters parameters, MVEntry mventry)
{
List <object> values = new List <object>();
foreach (string attributeName in parameters.SourceAttributeNames)
{
if (attributeName == "MVObjectID")
{
values.Add(mventry.ObjectID.ToString());
}
else
{
Attrib attribute = mventry[attributeName];
if (attribute.IsMultivalued)
{
values.AddRange(this.GetMVAttributeValue(attribute));
}
else
{
values.Add(this.GetSVAttributeValue(attribute));
}
}
}
return(values);
}
void IMASynchronization.MapAttributesForExport(string flowRuleName, MVEntry mventry, CSEntry csentry)
{
FlowRuleParameters parameters = this.GetParameters(flowRuleName, FlowRuleType.Export);
if (!parameters.ShouldFlow(csentry, mventry))
{
throw new DeclineMappingException();
}
IList <object> sourceValues = this.GetSourceValuesForExport(parameters, mventry);
IList <object> returnValues;
if (parameters.Transforms.Any(t => t.ImplementsLoopbackProcessing))
{
IList <object> existingTargetValues = this.GetExistingTargetValueForExportLoopback(parameters, csentry);
returnValues = Transform.ExecuteTransformChainWithLoopback(parameters.Transforms, sourceValues, existingTargetValues);
}
else
{
returnValues = Transform.ExecuteTransformChain(parameters.Transforms, sourceValues);
}
this.SetDestinationAttributeValueForExport(parameters, csentry, returnValues);
}
private void SetDestinationAttributeValueForImport(FlowRuleParameters parameters, MVEntry mventry, IList <object> values, bool clearTarget)
{
Attrib attribute = mventry[parameters.TargetAttributeName];
if (clearTarget)
{
attribute.Delete();
}
this.SetDestinationAttributeValue(parameters, values, attribute);
}
private IList <object> GetExistingTargetValueForExportLoopback(FlowRuleParameters parameters, CSEntry csentry)
{
List <object> values = new List <object>();
Attrib attribute = csentry[parameters.TargetAttributeName];
if (attribute.IsPresent)
{
if (attribute.IsMultivalued)
{
values.AddRange(this.GetMVAttributeValue(attribute));
}
else
{
values.Add(this.GetSVAttributeValue(attribute));
}
}
return(values);
}
private IList <object> GetSourceValuesForImport(FlowRuleParameters parameters, CSEntry csentry, out AttributeType attributeType)
{
List <object> values = new List <object>();
attributeType = AttributeType.Undefined;
foreach (string attributeName in parameters.SourceAttributeNames)
{
if (attributeName == "DN")
{
values.Add(csentry.DN.ToString());
}
else
{
Attrib attribute = csentry[attributeName];
if (attributeType == AttributeType.Undefined)
{
attributeType = attribute.DataType;
}
else if (attributeType != attribute.DataType)
{
attributeType = AttributeType.String;
}
if (attribute.IsMultivalued)
{
values.AddRange(this.GetMVAttributeValue(attribute));
}
else
{
values.Add(this.GetSVAttributeValue(attribute));
}
}
}
return(values);
}
void IMASynchronization.MapAttributesForJoin(string flowRuleName, CSEntry csentry, ref ValueCollection values)
{
FlowRuleParameters parameters = this.GetParameters(flowRuleName, FlowRuleType.Join);
if (!parameters.ShouldFlow(csentry, null))
{
throw new DeclineMappingException();
}
AttributeType type;
IList <object> sourceValues = this.GetSourceValuesForImport(parameters, csentry, out type);
IList <object> returnValues = Transform.ExecuteTransformChain(parameters.Transforms, sourceValues);
foreach (object value in returnValues)
{
switch (type)
{
case AttributeType.Binary:
values.Add(TypeConverter.ConvertData <byte[]>(value));
break;
case AttributeType.Integer:
values.Add(TypeConverter.ConvertData <long>(value));
break;
case AttributeType.String:
values.Add(TypeConverter.ConvertData <string>(value));
break;
case AttributeType.Reference:
case AttributeType.Boolean:
case AttributeType.Undefined:
throw new UnknownOrUnsupportedDataTypeException();
}
}
}
private IList <object> GetSourceValuesFromMultipleConnectorsForImport(FlowRuleParameters parameters, CSEntry csentry, MVEntry mventry, out AttributeType attributeType)
{
List <object> values = new List <object>();
attributeType = AttributeType.Undefined;
IEnumerable <CSEntry> csentries = mventry.ConnectedMAs.OfType <ConnectedMA>().Where(t => t.Name == csentry.MA.Name).SelectMany(t => t.Connectors.OfType <CSEntry>());
foreach (string attributeName in parameters.SourceAttributeNames)
{
foreach (CSEntry othercsentry in csentries.Where(t => t.ObjectType == csentry.ObjectType))
{
Attrib attribute = othercsentry[attributeName];
if (attributeType == AttributeType.Undefined)
{
attributeType = attribute.DataType;
}
else if (attributeType != attribute.DataType)
{
attributeType = AttributeType.String;
}
if (attribute.IsMultivalued)
{
values.AddRange(this.GetMVAttributeValue(attribute));
}
else
{
values.Add(this.GetSVAttributeValue(attribute));
}
}
}
return(values);
}
private void SetDestinationAttributeValueForExport(FlowRuleParameters parameters, CSEntry csentry, IList <object> values)
{
Attrib attribute = csentry[parameters.TargetAttributeName];
this.SetDestinationAttributeValue(parameters, values, attribute);
}
