void IMAExtensible2CallExport.OpenExportConnection(System.Collections.ObjectModel.KeyedCollection <string, ConfigParameter> configParameters, Schema types, OpenExportConnectionRunStep exportRunStep)
{
Tracer.IndentLevel = 0;
Tracer.Enter("openexportconnection");
Tracer.Indent();
try
{
InitializeConfigParameters(configParameters);
OpenRunspace();
schema = types;
exportType = exportRunStep.ExportType;
Tracer.TraceInformation("export-type '{0}'", exportType);
exportBatchSize = exportRunStep.BatchSize;
Tracer.TraceInformation("export-batch-size '{0}'", exportBatchSize);
}
catch (Exception ex)
{
Tracer.TraceError("openexportconnection", ex);
throw new TerminateRunException(ex.Message);
}
finally
{
Tracer.Unindent();
Tracer.Exit("openexportconnection");
}
}
public Schema GetSchema(System.Collections.ObjectModel.KeyedCollection <string, ConfigParameter> configParameters)
{
Schema schema = Schema.Create();
Microsoft.MetadirectoryServices.SchemaType type;
//we want to fetch schema for all MAs, that way configuration wont get lost if an item is
//unselected, and the checkbox can become simply an activate/deactivate switch
DataSet mas = FIMConfiguration.GetManagementAgents(null);
foreach (DataRow ma in mas.Tables["Config"].Rows)
{
string maName = ma["ma_name"].ToString();
string maType = ma["ma_type"].ToString();
string maList = ma["ma_listname"].ToString();
if (maType.Equals("FIM", StringComparison.InvariantCultureIgnoreCase) ||
maList.Equals("Provisioning Management Agent (Insight)", StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
//create a new schema type based on the ma
type = Microsoft.MetadirectoryServices.SchemaType.Create(maName, false);
//add a generic Anchor Attribute to allow user to add flows for the actual anchor
type.Attributes.Add(SchemaAttribute.CreateAnchorAttribute("Anchor", AttributeType.String));
//we must preface each attribute with the MA name to make it unique across the schema allowing for
//an attribute in two different MAs with different data types, etc.
//our data will come back as XML data, we will need to parse it for what we need
XmlDocument xmldoc = FIMConfiguration.GetConfigXML(maName, "ma_schema_xml");
XmlNamespaceManager xmlnsManager = new XmlNamespaceManager(xmldoc.NameTable);
xmlnsManager.AddNamespace("dsml", "http://www.dsml.org/DSML");
xmlnsManager.AddNamespace("ms-dsml", "http://www.microsoft.com/MMS/DSML");
XmlNodeList attributes = xmldoc.SelectNodes("//dsml:directory-schema/dsml:attribute-type", xmlnsManager);
//add each attribute found to the schema
foreach (XmlNode attrib in attributes)
{
string oid = attrib.SelectSingleNode("./dsml:syntax", xmlnsManager).InnerText;
type.Attributes.Add(SchemaAttribute.CreateSingleValuedAttribute(maName + " - " + attrib.Attributes["id"].Value, FIMConfiguration.GetDataType(oid)));
}
schema.Types.Add(type);
}
return(schema);
}
public OpenImportConnectionResults OpenImportConnection(System.Collections.ObjectModel.KeyedCollection <string, ConfigParameter> configParameters, Schema types, OpenImportConnectionRunStep importRunStep)
{
throw new NotImplementedException();
}
public ParameterValidationResult ValidateConfigParameters(System.Collections.ObjectModel.KeyedCollection <string, ConfigParameter> configParameters, ConfigParameterPage page)
{
ParameterValidationResult myResults = new ParameterValidationResult();
return(myResults);
}
public System.Collections.Generic.IList <ConfigParameterDefinition> GetConfigParameters(System.Collections.ObjectModel.KeyedCollection <string, ConfigParameter> configParameters, ConfigParameterPage page)
{
List <ConfigParameterDefinition> configParametersDefinitions = new List <ConfigParameterDefinition>();
switch (page)
{
case ConfigParameterPage.Connectivity:
//we have to configure the MAs being seletected in the Connectivity page so that the information
//will be available to us when fetching the schema for the items selected
configParametersDefinitions.Add(ConfigParameterDefinition.CreateLabelParameter("Enable provisioning for the following types:"));
//look up MAs and list them as check boxes for provisioning enablement
DataSet mas = FIMConfiguration.GetManagementAgents(null);
foreach (DataRow ma in mas.Tables["Config"].Rows)
{
string maName = ma["ma_name"].ToString();
string maType = ma["ma_type"].ToString();
string maList = ma["ma_listname"].ToString();
if (maType.Equals("FIM", StringComparison.InvariantCultureIgnoreCase) ||
maList.Equals("Provisioning Management Agent (Insight)", StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
//our data will come back as XML data, we will need to parse it for what we need
XmlDocument xmldoc = FIMConfiguration.GetConfigXML(maName, "ma_schema_xml");
XmlNamespaceManager xmlnsManager = new XmlNamespaceManager(xmldoc.NameTable);
xmlnsManager.AddNamespace("dsml", "http://www.dsml.org/DSML");
xmlnsManager.AddNamespace("ms-dsml", "http://www.microsoft.com/MMS/DSML");
//TODO: what happens when a sql column defines the object type?
XmlNodeList objectTypes = xmldoc.SelectNodes("//dsml:directory-schema/dsml:class", xmlnsManager);
foreach (XmlNode ot in objectTypes)
{
//add the object type as a selection
ConfigParameterDefinition conf = ConfigParameterDefinition.CreateCheckBoxParameter(maName + " - " + ot.Attributes["id"].Value.Replace(" - ", " _ "));
configParametersDefinitions.Add(conf);
}
//TODO: what happens to the UI when we have a alot of entries?
configParametersDefinitions.Add(ConfigParameterDefinition.CreateDividerParameter());
}
break;
case ConfigParameterPage.Global:
break;
case ConfigParameterPage.Partition:
break;
case ConfigParameterPage.RunStep:
break;
}
return(configParametersDefinitions);
}
public void Populate()
{
#region Types of Keywords
FieldPublicDynamic = new { PropPublic1 = "A", PropPublic2 = 1, PropPublic3 = "B", PropPublic4 = "B", PropPublic5 = "B", PropPublic6 = "B", PropPublic7 = "B", PropPublic8 = "B", PropPublic9 = "B", PropPublic10 = "B", PropPublic11 = "B", PropPublic12 = new { PropSubPublic1 = 0, PropSubPublic2 = 1, PropSubPublic3 = 2 } };
FieldPublicObject = new StringBuilder("Object - StringBuilder");
FieldPublicInt32 = int.MaxValue;
FieldPublicInt64 = long.MaxValue;
FieldPublicULong = ulong.MaxValue;
FieldPublicUInt = uint.MaxValue;
FieldPublicDecimal = 100000.999999m;
FieldPublicDouble = 100000.999999d;
FieldPublicChar = 'A';
FieldPublicByte = byte.MaxValue;
FieldPublicBoolean = true;
FieldPublicSByte = sbyte.MaxValue;
FieldPublicShort = short.MaxValue;
FieldPublicUShort = ushort.MaxValue;
FieldPublicFloat = 100000.675555f;
FieldPublicInt32Nullable = int.MaxValue;
FieldPublicInt64Nullable = 2;
FieldPublicULongNullable = ulong.MaxValue;
FieldPublicUIntNullable = uint.MaxValue;
FieldPublicDecimalNullable = 100000.999999m;
FieldPublicDoubleNullable = 100000.999999d;
FieldPublicCharNullable = 'A';
FieldPublicByteNullable = byte.MaxValue;
FieldPublicBooleanNullable = true;
FieldPublicSByteNullable = sbyte.MaxValue;
FieldPublicShortNullable = short.MaxValue;
FieldPublicUShortNullable = ushort.MaxValue;
FieldPublicFloatNullable = 100000.675555f;
#endregion
#region System
FieldPublicDateTime = new DateTime(2000, 1, 1, 1, 1, 1);
FieldPublicTimeSpan = new TimeSpan(1, 10, 40);
FieldPublicEnumDateTimeKind = DateTimeKind.Local;
// Instantiate date and time using Persian calendar with years,
// months, days, hours, minutes, seconds, and milliseconds
FieldPublicDateTimeOffset = new DateTimeOffset(1387, 2, 12, 8, 6, 32, 545,
new System.Globalization.PersianCalendar(),
new TimeSpan(1, 0, 0));
FieldPublicIntPtr = new IntPtr(100);
FieldPublicTimeZone = TimeZone.CurrentTimeZone;
FieldPublicTimeZoneInfo = TimeZoneInfo.Utc;
FieldPublicTuple = Tuple.Create <string, int, decimal>("T-string\"", 1, 1.1m);
FieldPublicType = typeof(object);
FieldPublicUIntPtr = new UIntPtr(100);
FieldPublicUri = new Uri("http://www.site.com");
FieldPublicVersion = new Version(1, 0, 100, 1);
FieldPublicGuid = new Guid("d5010f5b-0cd1-44ca-aacb-5678b9947e6c");
FieldPublicSingle = Single.MaxValue;
FieldPublicException = new Exception("Test error", new Exception("inner exception"));
FieldPublicEnumNonGeneric = EnumTest.ValueA;
FieldPublicAction = () => true.Equals(true);
FieldPublicAction2 = (a, b) => true.Equals(true);
FieldPublicFunc = () => true;
FieldPublicFunc2 = (a, b) => true;
#endregion
#region Arrays and Collections
FieldPublicArrayUni = new string[2];
FieldPublicArrayUni[0] = "[0]";
FieldPublicArrayUni[1] = "[1]";
FieldPublicArrayTwo = new string[2, 2];
FieldPublicArrayTwo[0, 0] = "[0, 0]";
FieldPublicArrayTwo[0, 1] = "[0, 1]";
FieldPublicArrayTwo[1, 0] = "[1, 0]";
FieldPublicArrayTwo[1, 1] = "[1, 1]";
FieldPublicArrayThree = new string[1, 1, 2];
FieldPublicArrayThree[0, 0, 0] = "[0, 0, 0]";
FieldPublicArrayThree[0, 0, 1] = "[0, 0, 1]";
FieldPublicJaggedArrayTwo = new string[2][];
FieldPublicJaggedArrayTwo[0] = new string[5] {
"a", "b", "c", "d", "e"
};
FieldPublicJaggedArrayTwo[1] = new string[4] {
"a1", "b1", "c1", "d1"
};
FieldPublicJaggedArrayThree = new string[1][][];
FieldPublicJaggedArrayThree[0] = new string[1][];
FieldPublicJaggedArrayThree[0][0] = new string[2];
FieldPublicJaggedArrayThree[0][0][0] = "[0][0][0]";
FieldPublicJaggedArrayThree[0][0][1] = "[0][0][1]";
FieldPublicMixedArrayAndJagged = new int[3][, ]
{
new int[, ] {
{ 1, 3 }, { 5, 7 }
},
new int[, ] {
{ 0, 2 }, { 4, 6 }, { 8, 10 }
},
new int[, ] {
{ 11, 22 }, { 99, 88 }, { 0, 9 }
}
};
FieldPublicDictionary = new System.Collections.Generic.Dictionary <string, string>();
FieldPublicDictionary.Add("Key1", "Value1");
FieldPublicDictionary.Add("Key2", "Value2");
FieldPublicDictionary.Add("Key3", "Value3");
FieldPublicDictionary.Add("Key4", "Value4");
FieldPublicList = new System.Collections.Generic.List <int>();
FieldPublicList.Add(0);
FieldPublicList.Add(1);
FieldPublicList.Add(2);
FieldPublicQueue = new System.Collections.Generic.Queue <int>();
FieldPublicQueue.Enqueue(10);
FieldPublicQueue.Enqueue(11);
FieldPublicQueue.Enqueue(12);
FieldPublicHashSet = new System.Collections.Generic.HashSet <string>();
FieldPublicHashSet.Add("HashSet1");
FieldPublicHashSet.Add("HashSet2");
FieldPublicSortedSet = new System.Collections.Generic.SortedSet <string>();
FieldPublicSortedSet.Add("SortedSet1");
FieldPublicSortedSet.Add("SortedSet2");
FieldPublicSortedSet.Add("SortedSet3");
FieldPublicStack = new System.Collections.Generic.Stack <string>();
FieldPublicStack.Push("Stack1");
FieldPublicStack.Push("Stack2");
FieldPublicStack.Push("Stack3");
FieldPublicLinkedList = new System.Collections.Generic.LinkedList <string>();
FieldPublicLinkedList.AddFirst("LinkedList1");
FieldPublicLinkedList.AddLast("LinkedList2");
FieldPublicLinkedList.AddAfter(FieldPublicLinkedList.Find("LinkedList1"), "LinkedList1.1");
FieldPublicObservableCollection = new System.Collections.ObjectModel.ObservableCollection <string>();
FieldPublicObservableCollection.Add("ObservableCollection1");
FieldPublicObservableCollection.Add("ObservableCollection2");
FieldPublicKeyedCollection = new MyDataKeyedCollection();
FieldPublicKeyedCollection.Add(new MyData()
{
Data = "data1", Id = 0
});
FieldPublicKeyedCollection.Add(new MyData()
{
Data = "data2", Id = 1
});
var list = new List <string>();
list.Add("list1");
list.Add("list2");
list.Add("list3");
FieldPublicReadOnlyCollection = new ReadOnlyCollection <string>(list);
FieldPublicReadOnlyDictionary = new ReadOnlyDictionary <string, string>(FieldPublicDictionary);
FieldPublicReadOnlyObservableCollection = new ReadOnlyObservableCollection <string>(FieldPublicObservableCollection);
FieldPublicCollection = new Collection <string>();
FieldPublicCollection.Add("collection1");
FieldPublicCollection.Add("collection2");
FieldPublicCollection.Add("collection3");
FieldPublicArrayListNonGeneric = new System.Collections.ArrayList();
FieldPublicArrayListNonGeneric.Add(1);
FieldPublicArrayListNonGeneric.Add("a");
FieldPublicArrayListNonGeneric.Add(10.0m);
FieldPublicArrayListNonGeneric.Add(new DateTime(2000, 01, 01));
FieldPublicBitArray = new System.Collections.BitArray(3);
FieldPublicBitArray[2] = true;
FieldPublicSortedList = new System.Collections.SortedList();
FieldPublicSortedList.Add("key1", 1);
FieldPublicSortedList.Add("key2", 2);
FieldPublicSortedList.Add("key3", 3);
FieldPublicSortedList.Add("key4", 4);
FieldPublicHashtableNonGeneric = new System.Collections.Hashtable();
FieldPublicHashtableNonGeneric.Add("key1", 1);
FieldPublicHashtableNonGeneric.Add("key2", 2);
FieldPublicHashtableNonGeneric.Add("key3", 3);
FieldPublicHashtableNonGeneric.Add("key4", 4);
FieldPublicQueueNonGeneric = new System.Collections.Queue();
FieldPublicQueueNonGeneric.Enqueue("QueueNonGeneric1");
FieldPublicQueueNonGeneric.Enqueue("QueueNonGeneric2");
FieldPublicQueueNonGeneric.Enqueue("QueueNonGeneric3");
FieldPublicStackNonGeneric = new System.Collections.Stack();
FieldPublicStackNonGeneric.Push("StackNonGeneric1");
FieldPublicStackNonGeneric.Push("StackNonGeneric2");
FieldPublicIEnumerable = FieldPublicSortedList;
FieldPublicBlockingCollection = new System.Collections.Concurrent.BlockingCollection <string>();
FieldPublicBlockingCollection.Add("BlockingCollection1");
FieldPublicBlockingCollection.Add("BlockingCollection2");
FieldPublicConcurrentBag = new System.Collections.Concurrent.ConcurrentBag <string>();
FieldPublicConcurrentBag.Add("ConcurrentBag1");
FieldPublicConcurrentBag.Add("ConcurrentBag2");
FieldPublicConcurrentBag.Add("ConcurrentBag3");
FieldPublicConcurrentDictionary = new System.Collections.Concurrent.ConcurrentDictionary <string, int>();
FieldPublicConcurrentDictionary.GetOrAdd("ConcurrentDictionary1", 0);
FieldPublicConcurrentDictionary.GetOrAdd("ConcurrentDictionary2", 0);
FieldPublicConcurrentQueue = new System.Collections.Concurrent.ConcurrentQueue <string>();
FieldPublicConcurrentQueue.Enqueue("ConcurrentQueue1");
FieldPublicConcurrentQueue.Enqueue("ConcurrentQueue2");
FieldPublicConcurrentStack = new System.Collections.Concurrent.ConcurrentStack <string>();
FieldPublicConcurrentStack.Push("ConcurrentStack1");
FieldPublicConcurrentStack.Push("ConcurrentStack2");
// FieldPublicOrderablePartitioner = new OrderablePartitioner();
// FieldPublicPartitioner;
// FieldPublicPartitionerNonGeneric;
FieldPublicHybridDictionary = new System.Collections.Specialized.HybridDictionary();
FieldPublicHybridDictionary.Add("HybridDictionaryKey1", "HybridDictionary1");
FieldPublicHybridDictionary.Add("HybridDictionaryKey2", "HybridDictionary2");
FieldPublicListDictionary = new System.Collections.Specialized.ListDictionary();
FieldPublicListDictionary.Add("ListDictionaryKey1", "ListDictionary1");
FieldPublicListDictionary.Add("ListDictionaryKey2", "ListDictionary2");
FieldPublicNameValueCollection = new System.Collections.Specialized.NameValueCollection();
FieldPublicNameValueCollection.Add("Key1", "Value1");
FieldPublicNameValueCollection.Add("Key2", "Value2");
FieldPublicOrderedDictionary = new System.Collections.Specialized.OrderedDictionary();
FieldPublicOrderedDictionary.Add(1, "OrderedDictionary1");
FieldPublicOrderedDictionary.Add(2, "OrderedDictionary1");
FieldPublicOrderedDictionary.Add("OrderedDictionaryKey2", "OrderedDictionary2");
FieldPublicStringCollection = new System.Collections.Specialized.StringCollection();
FieldPublicStringCollection.Add("StringCollection1");
FieldPublicStringCollection.Add("StringCollection2");
#endregion
#region Several
PropXmlDocument = new XmlDocument();
PropXmlDocument.LoadXml("<xml>something</xml>");
var tr = new StringReader("<Root>Content</Root>");
PropXDocument = XDocument.Load(tr);
PropStream = GenerateStreamFromString("Stream");
PropBigInteger = new System.Numerics.BigInteger(100);
PropStringBuilder = new StringBuilder("StringBuilder");
FieldPublicIQueryable = new List <string>()
{
"IQueryable"
}.AsQueryable();
#endregion
#region Custom
FieldPublicMyCollectionPublicGetEnumerator = new MyCollectionPublicGetEnumerator("a b c", new char[] { ' ' });
FieldPublicMyCollectionInheritsPublicGetEnumerator = new MyCollectionInheritsPublicGetEnumerator("a b c", new char[] { ' ' });
FieldPublicMyCollectionExplicitGetEnumerator = new MyCollectionExplicitGetEnumerator("a b c", new char[] { ' ' });
FieldPublicMyCollectionInheritsExplicitGetEnumerator = new MyCollectionInheritsExplicitGetEnumerator("a b c", new char[] { ' ' });
FieldPublicMyCollectionInheritsTooIEnumerable = new MyCollectionInheritsTooIEnumerable("a b c", new char[] { ' ' });
FieldPublicEnumSpecific = EnumTest.ValueB;
MyDelegate = MethodDelegate;
EmptyClass = new EmptyClass();
StructGeneric = new ThreeTuple <int>(0, 1, 2);
StructGenericNullable = new ThreeTuple <int>(0, 1, 2);
FieldPublicNullable = new Nullable <ThreeTuple <int> >(StructGeneric);
#endregion
}
public void InitializeConfigParameters(System.Collections.ObjectModel.KeyedCollection <string, ConfigParameter> configParameters)
{
Tracer.Enter(nameof(InitializeConfigParameters));
try
{
if (configParameters != null)
{
foreach (ConfigParameter cp in configParameters)
{
Tracer.TraceInformation("{0}: '{1}'", cp.Name, cp.IsEncrypted ? "*** secret ***" : cp.Value);
if (cp.Name.Equals(Configuration.Parameters.SchemaConfiguration))
{
Configuration.Schema = configParameters[cp.Name].Value.XmlDeserializeFromString <SchemaConfiguration>();
}
if (cp.Name.Equals(Configuration.Parameters.TypeOfAuthentication))
{
Configuration.TypeOfAuthentication = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.Username))
{
Configuration.UserName = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.Password))
{
Configuration.Password = configParameters[cp.Name].SecureValue.ConvertToUnsecureString();
}
if (cp.Name.Equals(Configuration.Parameters.Domain))
{
Configuration.Domain = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.ConnectionString))
{
Configuration.ConnectionString = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.TableNameSingleValue))
{
Configuration.TableNameSingle = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.TableNameMultiValue))
{
Configuration.TableNameMulti = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.ColumnAnchor))
{
Configuration.AnchorColumn = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.ColumnMVAnchorReference))
{
Configuration.BackReferenceColumn = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.ColumnOrValueObjectClass))
{
Configuration.ObjectClass = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.ColumnDelta))
{
Configuration.DeltaColumn = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.ColumnIsDeleted))
{
Configuration.DeletedColumn = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.ColumnDN))
{
Configuration.DNColumn = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.ImportCommandBefore))
{
Configuration.ImportCommandBefore = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.ImportCommandAfter))
{
Configuration.ImportCommandAfter = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.ExportCommandBefore))
{
Configuration.ExportCommandBefore = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.ExportCommandAfter))
{
Configuration.ExportCommandAfter = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.ExportObjectCommandBefore))
{
Configuration.ExportObjectCommandBefore = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.ExportObjectCommandAfter))
{
Configuration.ExportObjectCommandAfter = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.DateFormat))
{
Configuration.DateFormat = configParameters[cp.Name].Value;
}
if (cp.Name.Equals(Configuration.Parameters.TypeOfObjectClass))
{
switch (configParameters[cp.Name].Value)
{
case "Column":
Configuration.ObjectClassType = ObjectClassType.Column;
break;
case "Fixed":
Configuration.ObjectClassType = ObjectClassType.Fixed;
break;
default:
Configuration.ObjectClassType = ObjectClassType.Column;
break;
}
}
if (cp.Name.Equals(Configuration.Parameters.TypeOfDelta))
{
switch (configParameters[cp.Name].Value)
{
case "Rowversion":
Configuration.DeltaColumnType = DeltaColumnType.Rowversion;
break;
case "DateTime":
Configuration.DeltaColumnType = DeltaColumnType.DateTime;
break;
default:
Configuration.DeltaColumnType = DeltaColumnType.Rowversion;
break;
}
}
}
}
}
catch (Exception ex)
{
Tracer.TraceError(nameof(InitializeConfigParameters), ex);
throw;
}
finally
{
Tracer.Exit(nameof(InitializeConfigParameters));
}
}
