public int Add(ActiveDirectorySchemaClass schemaClass) { if (schemaClass != null) { if (schemaClass.isBound) { if (this.Contains(schemaClass)) { object[] objArray = new object[1]; objArray[0] = schemaClass; throw new ArgumentException(Res.GetString("AlreadyExistingInCollection", objArray), "schemaClass"); } else { return base.List.Add(schemaClass); } } else { object[] name = new object[1]; name[0] = schemaClass.Name; throw new InvalidOperationException(Res.GetString("SchemaObjectNotCommitted", name)); } } else { throw new ArgumentNullException("schemaClass"); } }
public int IndexOf(ActiveDirectorySchemaClass schemaClass) { Contract.Requires(schemaClass != null); Contract.Ensures(Contract.Result<int>() >= -1); Contract.Ensures(Contract.Result<int>() < this.Count); return default(int); }
internal ActiveDirectorySchemaPropertyCollection(DirectoryContext context, ActiveDirectorySchemaClass schemaClass, bool isBound, string propertyName, ICollection properties) { this.schemaClass = schemaClass; this.propertyName = propertyName; this.isBound = isBound; this.context = context; foreach (ActiveDirectorySchemaProperty property in properties) { base.InnerList.Add(property); } }
internal ActiveDirectorySchemaPropertyCollection(DirectoryContext context, ActiveDirectorySchemaClass schemaClass, bool isBound, string propertyName, ICollection propertyNames, bool onlyNames) { this.schemaClass = schemaClass; this.propertyName = propertyName; this.isBound = isBound; this.context = context; foreach (string str in propertyNames) { base.InnerList.Add(new ActiveDirectorySchemaProperty(context, str, null, null)); } }
public int Add(ActiveDirectorySchemaClass schemaClass) { if (schemaClass == null) { throw new ArgumentNullException("schemaClass"); } if (!schemaClass.isBound) { throw new InvalidOperationException(Res.GetString("SchemaObjectNotCommitted", new object[] { schemaClass.Name })); } if (this.Contains(schemaClass)) { throw new ArgumentException(Res.GetString("AlreadyExistingInCollection", new object[] { schemaClass }), "schemaClass"); } return base.List.Add(schemaClass); }
internal ActiveDirectorySchemaPropertyCollection(DirectoryContext context, ActiveDirectorySchemaClass schemaClass, bool isBound, string propertyName, ICollection properties) { _schemaClass = schemaClass; _propertyName = propertyName; _isBound = isBound; _context = context; foreach (ActiveDirectorySchemaProperty schemaProperty in properties) { this.InnerList.Add(schemaProperty); } }
public int IndexOf(ActiveDirectorySchemaClass schemaClass) { if (schemaClass == null) { throw new ArgumentNullException("schemaClass"); } for (int i = 0; i < base.InnerList.Count; i++) { ActiveDirectorySchemaClass class2 = (ActiveDirectorySchemaClass) base.InnerList[i]; if (Utils.Compare(class2.Name, schemaClass.Name) == 0) { return i; } } return -1; }
internal ActiveDirectorySchemaPropertyCollection(DirectoryContext context, ActiveDirectorySchemaClass schemaClass, bool isBound, string propertyName, ICollection propertyNames, bool onlyNames) { _schemaClass = schemaClass; _propertyName = propertyName; _isBound = isBound; _context = context; foreach (string ldapDisplayName in propertyNames) { // all properties in writeable property collection are non-defunct // so calling constructor for non-defunct property this.InnerList.Add(new ActiveDirectorySchemaProperty(context, ldapDisplayName, (DirectoryEntry)null, null)); } }
public void AddRange(ActiveDirectorySchemaClass[] schemaClasses) { if (schemaClasses == null) { throw new ArgumentNullException("schemaClasses"); } ActiveDirectorySchemaClass[] classArray = schemaClasses; for (int i = 0; i < classArray.Length; i++) { if (classArray[i] == null) { throw new ArgumentException("schemaClasses"); } } for (int j = 0; j < schemaClasses.Length; j++) { this.Add(schemaClasses[j]); } }
internal ActiveDirectorySchemaClassCollection(DirectoryContext context, ActiveDirectorySchemaClass schemaClass, bool isBound, string propertyName, ICollection classNames, bool onlyNames) { _schemaClass = schemaClass; _propertyName = propertyName; _isBound = isBound; _context = context; foreach (string ldapDisplayName in classNames) { // all properties in writeable class collection are non-defunct // so calling constructor for non-defunct class InnerList.Add(new ActiveDirectorySchemaClass(context, ldapDisplayName, (DirectoryEntry)null, null)); } }
public int IndexOf(ActiveDirectorySchemaClass schemaClass) { if (schemaClass == null) { throw new ArgumentNullException("schemaClass"); } if (!schemaClass.isBound) { throw new InvalidOperationException(Res.GetString("SchemaObjectNotCommitted", new object[] { schemaClass.Name })); } for (int i = 0; i < base.InnerList.Count; i++) { ActiveDirectorySchemaClass class2 = (ActiveDirectorySchemaClass)base.InnerList[i]; if (Utils.Compare(class2.Name, schemaClass.Name) == 0) { return(i); } } return(-1); }
public void Insert(int index, ActiveDirectorySchemaClass schemaClass) { if (schemaClass == null) { throw new ArgumentNullException("schemaClass"); } if (!schemaClass.isBound) { throw new InvalidOperationException(Res.GetString(Res.SchemaObjectNotCommitted, schemaClass.Name)); } if (!Contains(schemaClass)) { List.Insert(index, schemaClass); } else { throw new ArgumentException(Res.GetString(Res.AlreadyExistingInCollection, schemaClass), "schemaClass"); } }
public void Remove(ActiveDirectorySchemaClass schemaClass) { if (schemaClass == null) { throw new ArgumentNullException("schemaClass"); } if (!schemaClass.isBound) { throw new InvalidOperationException(Res.GetString("SchemaObjectNotCommitted", new object[] { schemaClass.Name })); } for (int i = 0; i < base.InnerList.Count; i++) { ActiveDirectorySchemaClass class2 = (ActiveDirectorySchemaClass)base.InnerList[i]; if (Utils.Compare(class2.Name, schemaClass.Name) == 0) { base.List.Remove(class2); return; } } throw new ArgumentException(Res.GetString("NotFoundInCollection", new object[] { schemaClass }), "schemaClass"); }
public int Add(ActiveDirectorySchemaClass schemaClass) { if (schemaClass == null) { throw new ArgumentNullException("schemaClass"); } if (!schemaClass.isBound) { throw new InvalidOperationException(Res.GetString(Res.SchemaObjectNotCommitted, schemaClass.Name)); } if (!Contains(schemaClass)) { return List.Add(schemaClass); } else { throw new ArgumentException(Res.GetString(Res.AlreadyExistingInCollection, schemaClass), "schemaClass"); } }
public int Add(ActiveDirectorySchemaClass schemaClass) { if (schemaClass == null) { throw new ArgumentNullException("schemaClass"); } if (!schemaClass.isBound) { throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, SR.SchemaObjectNotCommitted, schemaClass.Name)); } if (!Contains(schemaClass)) { return(List.Add(schemaClass)); } else { throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, SR.AlreadyExistingInCollection, schemaClass), "schemaClass"); } }
// // This method finds only among defunct classes // public ActiveDirectorySchemaClass FindDefunctClass(string commonName) { CheckIfDisposed(); if (commonName == null) { throw new ArgumentNullException(nameof(commonName)); } if (commonName.Length == 0) { throw new ArgumentException(SR.EmptyStringParameter, nameof(commonName)); } // this will bind to the schema container and load the properties of this class // (will also check whether or not the class exists) Hashtable propertiesFromServer = ActiveDirectorySchemaClass.GetPropertiesFromSchemaContainer(context, _schemaEntry, commonName, true /* isDefunctOnServer */); ActiveDirectorySchemaClass schemaClass = new ActiveDirectorySchemaClass(context, commonName, propertiesFromServer, _schemaEntry); return(schemaClass); }
public ActiveDirectorySchemaClass FindDefunctClass(string commonName) { base.CheckIfDisposed(); if (commonName != null) { if (commonName.Length != 0) { Hashtable propertiesFromSchemaContainer = ActiveDirectorySchemaClass.GetPropertiesFromSchemaContainer(this.context, this.schemaEntry, commonName, true); ActiveDirectorySchemaClass activeDirectorySchemaClass = new ActiveDirectorySchemaClass(this.context, commonName, propertiesFromSchemaContainer, this.schemaEntry); return(activeDirectorySchemaClass); } else { throw new ArgumentException(Res.GetString("EmptyStringParameter"), "commonName"); } } else { throw new ArgumentNullException("commonName"); } }
public bool Contains(ActiveDirectorySchemaClass schemaClass) { if (schemaClass == null) { throw new ArgumentNullException("schemaClass"); } if (!schemaClass.isBound) { throw new InvalidOperationException(Res.GetString(Res.SchemaObjectNotCommitted, schemaClass.Name)); } for (int i = 0; i < InnerList.Count; i++) { ActiveDirectorySchemaClass tmp = (ActiveDirectorySchemaClass)InnerList[i]; if (Utils.Compare(tmp.Name, schemaClass.Name) == 0) { return(true); } } return(false); }
public int IndexOf(ActiveDirectorySchemaClass schemaClass) { if (schemaClass == null) { throw new ArgumentNullException("schemaClass"); } if (!schemaClass.isBound) { throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, SR.SchemaObjectNotCommitted, schemaClass.Name)); } for (int i = 0; i < InnerList.Count; i++) { ActiveDirectorySchemaClass tmp = (ActiveDirectorySchemaClass)InnerList[i]; if (Utils.Compare(tmp.Name, schemaClass.Name) == 0) { return(i); } } return(-1); }
public void Remove(ActiveDirectorySchemaClass schemaClass) { if (schemaClass == null) { throw new ArgumentNullException("schemaClass"); } if (!schemaClass.isBound) { throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, SR.SchemaObjectNotCommitted, schemaClass.Name)); } for (int i = 0; i < InnerList.Count; i++) { ActiveDirectorySchemaClass tmp = (ActiveDirectorySchemaClass)InnerList[i]; if (Utils.Compare(tmp.Name, schemaClass.Name) == 0) { List.Remove(tmp); return; } } throw new ArgumentException(String.Format(CultureInfo.CurrentCulture, SR.NotFoundInCollection, schemaClass), "schemaClass"); }
public int IndexOf(ActiveDirectorySchemaClass schemaClass) { if (schemaClass != null) { int num = 0; while (num < base.InnerList.Count) { ActiveDirectorySchemaClass item = (ActiveDirectorySchemaClass)base.InnerList[num]; if (Utils.Compare(item.Name, schemaClass.Name) != 0) { num++; } else { return(num); } } return(-1); } else { throw new ArgumentNullException("schemaClass"); } }
public void Remove(ActiveDirectorySchemaClass schemaClass) { if (schemaClass != null) { if (schemaClass.isBound) { int num = 0; while (num < base.InnerList.Count) { ActiveDirectorySchemaClass item = (ActiveDirectorySchemaClass)base.InnerList[num]; if (Utils.Compare(item.Name, schemaClass.Name) != 0) { num++; } else { base.List.Remove(item); return; } } object[] objArray = new object[1]; objArray[0] = schemaClass; throw new ArgumentException(Res.GetString("NotFoundInCollection", objArray), "schemaClass"); } else { object[] name = new object[1]; name[0] = schemaClass.Name; throw new InvalidOperationException(Res.GetString("SchemaObjectNotCommitted", name)); } } else { throw new ArgumentNullException("schemaClass"); } }
// // This method finds only among non-defunct classes // public ActiveDirectorySchemaClass FindClass(string ldapDisplayName) { CheckIfDisposed(); return(ActiveDirectorySchemaClass.FindByName(context, ldapDisplayName)); }
public static ActiveDirectorySchemaClass FindByName(DirectoryContext context, string ldapDisplayName) { ActiveDirectorySchemaClass schemaClass = null; if (context == null) { throw new ArgumentNullException("context"); } if ((context.Name == null) && (!context.isRootDomain())) { throw new ArgumentException(Res.GetString(Res.ContextNotAssociatedWithDomain), "context"); } if (context.Name != null) { if (!(context.isRootDomain() || context.isServer() || context.isADAMConfigSet())) { throw new ArgumentException(Res.GetString(Res.NotADOrADAM), "context"); } } if (ldapDisplayName == null) { throw new ArgumentNullException("ldapDisplayName"); } if (ldapDisplayName.Length == 0) { throw new ArgumentException(Res.GetString(Res.EmptyStringParameter), "ldapDisplayName"); } // work with copy of the context context = new DirectoryContext(context); // create a schema class schemaClass = new ActiveDirectorySchemaClass(context, ldapDisplayName, (DirectoryEntry)null, null); return schemaClass; }
// // This method searches in the schema container for all non-defunct classes of the // specified name (ldapDisplayName). // private ArrayList GetClasses(ICollection ldapDisplayNames) { ArrayList classes = new ArrayList(); SearchResultCollection resCol = null; try { if (ldapDisplayNames.Count < 1) { return classes; } if (_schemaEntry == null) { _schemaEntry = DirectoryEntryManager.GetDirectoryEntry(_context, WellKnownDN.SchemaNamingContext); } // constructing the filter StringBuilder str = new StringBuilder(100); if (ldapDisplayNames.Count > 1) { str.Append("(|"); } foreach (string ldapDisplayName in ldapDisplayNames) { str.Append("("); str.Append(PropertyManager.LdapDisplayName); str.Append("="); str.Append(Utils.GetEscapedFilterValue(ldapDisplayName)); str.Append(")"); } if (ldapDisplayNames.Count > 1) { str.Append(")"); } string filter = "(&(" + PropertyManager.ObjectCategory + "=classSchema)" + str.ToString() + "(!(" + PropertyManager.IsDefunct + "=TRUE)))"; string[] propertiesToLoad = new String[1]; propertiesToLoad[0] = PropertyManager.LdapDisplayName; ADSearcher searcher = new ADSearcher(_schemaEntry, filter, propertiesToLoad, SearchScope.OneLevel); resCol = searcher.FindAll(); foreach (SearchResult res in resCol) { string ldapDisplayName = (string)PropertyManager.GetSearchResultPropertyValue(res, PropertyManager.LdapDisplayName); DirectoryEntry de = res.GetDirectoryEntry(); de.AuthenticationType = Utils.DefaultAuthType; de.Username = _context.UserName; de.Password = _context.Password; ActiveDirectorySchemaClass schemaClass = new ActiveDirectorySchemaClass(_context, ldapDisplayName, de, _schemaEntry); classes.Add(schemaClass); } } catch (COMException e) { throw ExceptionHelper.GetExceptionFromCOMException(_context, e); } finally { if (resCol != null) { resCol.Dispose(); } } return classes; }
public void CopyTo(ActiveDirectorySchemaClass[] classes, int index) { base.InnerList.CopyTo(classes, index); }
public int IndexOf (ActiveDirectorySchemaClass schemaClass) { throw new NotImplementedException (); }
public bool Contains (ActiveDirectorySchemaClass schemaClass) { throw new NotImplementedException (); }
public int Add(ActiveDirectorySchemaClass schemaClass) { Contract.Requires(schemaClass != null); return(default(int)); }
public void Remove(ActiveDirectorySchemaClass schemaClass) { Contract.Requires(schemaClass != null); }
public void Save() { this.CheckIfDisposed(); if (!this.isBound) { try { if (this.schemaEntry == null) { this.schemaEntry = DirectoryEntryManager.GetDirectoryEntry(this.context, WellKnownDN.SchemaNamingContext); } string escapedPath = Utils.GetEscapedPath("CN=" + this.commonName); this.classEntry = this.schemaEntry.Children.Add(escapedPath, "classSchema"); } catch (COMException exception) { throw ExceptionHelper.GetExceptionFromCOMException(this.context, exception); } catch (ActiveDirectoryObjectNotFoundException) { throw new ActiveDirectoryOperationException(Res.GetString("ADAMInstanceNotFoundInConfigSet", new object[] { this.context.Name })); } this.SetProperty(PropertyManager.LdapDisplayName, this.ldapDisplayName); this.SetProperty(PropertyManager.GovernsID, this.oid); this.SetProperty(PropertyManager.Description, this.description); if (this.possibleSuperiors != null) { this.classEntry.Properties[PropertyManager.PossibleSuperiors].AddRange(this.possibleSuperiors.GetMultiValuedProperty()); } if (this.mandatoryProperties != null) { this.classEntry.Properties[PropertyManager.MustContain].AddRange(this.mandatoryProperties.GetMultiValuedProperty()); } if (this.optionalProperties != null) { this.classEntry.Properties[PropertyManager.MayContain].AddRange(this.optionalProperties.GetMultiValuedProperty()); } if (this.subClassOf != null) { this.SetProperty(PropertyManager.SubClassOf, this.subClassOf.Name); } else { this.SetProperty(PropertyManager.SubClassOf, "top"); } this.SetProperty(PropertyManager.ObjectClassCategory, this.type); if (this.schemaGuidBinaryForm != null) { this.SetProperty(PropertyManager.SchemaIDGuid, this.schemaGuidBinaryForm); } if (this.defaultSDSddlForm != null) { this.SetProperty(PropertyManager.DefaultSecurityDescriptor, this.defaultSDSddlForm); } } try { this.classEntry.CommitChanges(); if (this.schema == null) { ActiveDirectorySchema schema = ActiveDirectorySchema.GetSchema(this.context); bool flag = false; DirectoryServer schemaRoleOwner = null; try { schemaRoleOwner = schema.SchemaRoleOwner; if (Utils.Compare(schemaRoleOwner.Name, this.context.GetServerName()) != 0) { DirectoryContext context = Utils.GetNewDirectoryContext(schemaRoleOwner.Name, DirectoryContextType.DirectoryServer, this.context); this.schema = ActiveDirectorySchema.GetSchema(context); } else { flag = true; this.schema = schema; } } finally { if (schemaRoleOwner != null) { schemaRoleOwner.Dispose(); } if (!flag) { schema.Dispose(); } } } this.schema.RefreshSchema(); } catch (COMException exception2) { throw ExceptionHelper.GetExceptionFromCOMException(this.context, exception2); } this.isDefunctOnServer = this.isDefunct; this.commonName = null; this.oid = null; this.description = null; this.descriptionInitialized = false; this.possibleSuperiors = null; this.auxiliaryClasses = null; this.possibleInferiors = null; this.mandatoryProperties = null; this.optionalProperties = null; this.subClassOf = null; this.typeInitialized = false; this.schemaGuidBinaryForm = null; this.defaultSDSddlForm = null; this.defaultSDSddlFormInitialized = false; this.propertiesFromSchemaContainerInitialized = false; this.isBound = true; }
// // This method finds only among defunct classes // public ActiveDirectorySchemaClass FindDefunctClass(string commonName) { CheckIfDisposed(); if (commonName == null) { throw new ArgumentNullException("commonName"); } if (commonName.Length == 0) { throw new ArgumentException(Res.GetString(Res.EmptyStringParameter), "commonName"); } // this will bind to the schema container and load the properties of this class // (will also check whether or not the class exists) Hashtable propertiesFromServer = ActiveDirectorySchemaClass.GetPropertiesFromSchemaContainer(context, _schemaEntry, commonName, true /* isDefunctOnServer */); ActiveDirectorySchemaClass schemaClass = new ActiveDirectorySchemaClass(context, commonName, propertiesFromServer, _schemaEntry); return schemaClass; }
public void CopyTo(ActiveDirectorySchemaClass[] schemaClasses, int index) { base.List.CopyTo(schemaClasses, index); }
public void Insert (int index, ActiveDirectorySchemaClass schemaClass) { throw new NotImplementedException (); }
public void Insert(int index, ActiveDirectorySchemaClass schemaClass) { Contract.Requires(schemaClass != null); }
public void CopyTo (ActiveDirectorySchemaClass[] schemaClasses, int index) { throw new NotImplementedException (); }
public bool Contains(ActiveDirectorySchemaClass schemaClass) { throw new NotImplementedException(); }
public int IndexOf(ActiveDirectorySchemaClass schemaClass) { throw new NotImplementedException(); }
public int IndexOf(ActiveDirectorySchemaClass schemaClass) { if (schemaClass != null) { if (schemaClass.isBound) { int num = 0; while (num < base.InnerList.Count) { ActiveDirectorySchemaClass item = (ActiveDirectorySchemaClass)base.InnerList[num]; if (Utils.Compare(item.Name, schemaClass.Name) != 0) { num++; } else { return num; } } return -1; } else { object[] name = new object[1]; name[0] = schemaClass.Name; throw new InvalidOperationException(Res.GetString("SchemaObjectNotCommitted", name)); } } else { throw new ArgumentNullException("schemaClass"); } }
public static void CreateNewClass() { // specify a common name string newClassCommonName = "new-Class"; // specify an lDAPDisplayName string newClassLdapDisplayName = "newClass"; // specify an OID value. The root name was generated by oidgen.exe string newClassOid = "1.2.840.113556.1.5.7000.111.28688.28684.8.240397.1734810.1181742.544876.1"; string subClassOf = "top"; string possibleSuperior = "organizationalUnit"; // add an optional attribute to the new schema class object // This example adds the new attribute created in the CreateNewAttribute method string newClassOptionalAttribute = newAttributeLdapDisplayName; // create a new class object ActiveDirectorySchemaClass newClass = new ActiveDirectorySchemaClass( adamContext, newClassLdapDisplayName); // set the attribute values for this schema class object newClass.CommonName = newClassCommonName; newClass.Oid = newClassOid; newClass.Type = SchemaClassType.Structural; // assign the parent class newClass.SubClassOf = ActiveDirectorySchemaClass.FindByName(adamContext, subClassOf); // add the previously created attribute as an optional attribute newClass.OptionalProperties.Add( ActiveDirectorySchemaProperty.FindByName(adamContext, newClassOptionalAttribute)); //add an OU as a possible superior so that this class can be //instantiated in an OU newClass.PossibleSuperiors.Add( ActiveDirectorySchemaClass.FindByName(adamContext, possibleSuperior)); // save the new class to the schema try { newClass.Save(); } catch (ActiveDirectoryObjectExistsException e) { // an schema object by this name already exists in the schema Console.WriteLine("The schema object {0} was not created. {0}", newClassLdapDisplayName, e.Message); return; } catch (ActiveDirectoryOperationException e) { // a call to the underlying directory was rejected Console.WriteLine("The schema object {0} was not created. {0}", newClassLdapDisplayName, e.Message); return; } Console.WriteLine("Class \"{0}\" created successfully.", newClassLdapDisplayName); }
private ArrayList GetClasses(ICollection ldapDisplayNames) { ArrayList list = new ArrayList(); SearchResultCollection results = null; try { if (ldapDisplayNames.Count >= 1) { if (this.schemaEntry == null) { this.schemaEntry = DirectoryEntryManager.GetDirectoryEntry(this.context, WellKnownDN.SchemaNamingContext); } StringBuilder builder = new StringBuilder(100); if (ldapDisplayNames.Count > 1) { builder.Append("(|"); } foreach (string str in ldapDisplayNames) { builder.Append("("); builder.Append(PropertyManager.LdapDisplayName); builder.Append("="); builder.Append(Utils.GetEscapedFilterValue(str)); builder.Append(")"); } if (ldapDisplayNames.Count > 1) { builder.Append(")"); } string filter = "(&(" + PropertyManager.ObjectCategory + "=classSchema)" + builder.ToString() + "(!(" + PropertyManager.IsDefunct + "=TRUE)))"; string[] propertiesToLoad = new string[] { PropertyManager.LdapDisplayName }; results = new ADSearcher(this.schemaEntry, filter, propertiesToLoad, SearchScope.OneLevel).FindAll(); foreach (SearchResult result in results) { string searchResultPropertyValue = (string) PropertyManager.GetSearchResultPropertyValue(result, PropertyManager.LdapDisplayName); DirectoryEntry directoryEntry = result.GetDirectoryEntry(); directoryEntry.AuthenticationType = Utils.DefaultAuthType; directoryEntry.Username = this.context.UserName; directoryEntry.Password = this.context.Password; ActiveDirectorySchemaClass class2 = new ActiveDirectorySchemaClass(this.context, searchResultPropertyValue, directoryEntry, this.schemaEntry); list.Add(class2); } } return list; } catch (COMException exception) { throw ExceptionHelper.GetExceptionFromCOMException(this.context, exception); } finally { if (results != null) { results.Dispose(); } } return list; }
public void Insert(int index, ActiveDirectorySchemaClass schemaClass) { throw new NotImplementedException(); }
private ArrayList GetPropertyValuesRecursively(string[] propertyNames) { ArrayList list = new ArrayList(); try { if (Utils.Compare(this.SubClassOf.Name, this.Name) != 0) { foreach (string str in this.SubClassOf.GetPropertyValuesRecursively(propertyNames)) { if (!list.Contains(str)) { list.Add(str); } } } foreach (string str2 in this.GetValuesFromCache(PropertyManager.AuxiliaryClass)) { ActiveDirectorySchemaClass class2 = new ActiveDirectorySchemaClass(this.context, str2, null, null); foreach (string str3 in class2.GetPropertyValuesRecursively(propertyNames)) { if (!list.Contains(str3)) { list.Add(str3); } } } foreach (string str4 in this.GetValuesFromCache(PropertyManager.SystemAuxiliaryClass)) { ActiveDirectorySchemaClass class3 = new ActiveDirectorySchemaClass(this.context, str4, null, null); foreach (string str5 in class3.GetPropertyValuesRecursively(propertyNames)) { if (!list.Contains(str5)) { list.Add(str5); } } } } catch (COMException exception) { throw ExceptionHelper.GetExceptionFromCOMException(this.context, exception); } foreach (string str6 in propertyNames) { foreach (string str7 in this.GetValuesFromCache(str6)) { if (!list.Contains(str7)) { list.Add(str7); } } } return list; }
public void Remove(ActiveDirectorySchemaClass schemaClass) { throw new NotImplementedException(); }
private ArrayList GetPropertyValuesRecursively(string[] propertyNames) { ArrayList values = new ArrayList(); // get the properties of the super class try { if (Utils.Compare(SubClassOf.Name, Name) != 0) { foreach (string value in SubClassOf.GetPropertyValuesRecursively(propertyNames)) { if (!values.Contains(value)) { values.Add(value); } } } // get the properties of the auxiliary classes foreach (string auxSchemaClassName in GetValuesFromCache(PropertyManager.AuxiliaryClass)) { ActiveDirectorySchemaClass auxSchemaClass = new ActiveDirectorySchemaClass(_context, auxSchemaClassName, (DirectoryEntry)null, null); foreach (string property in auxSchemaClass.GetPropertyValuesRecursively(propertyNames)) { if (!values.Contains(property)) { values.Add(property); } } } foreach (string auxSchemaClassName in GetValuesFromCache(PropertyManager.SystemAuxiliaryClass)) { ActiveDirectorySchemaClass auxSchemaClass = new ActiveDirectorySchemaClass(_context, auxSchemaClassName, (DirectoryEntry)null, null); foreach (string property in auxSchemaClass.GetPropertyValuesRecursively(propertyNames)) { if (!values.Contains(property)) { values.Add(property); } } } } catch (COMException e) { throw ExceptionHelper.GetExceptionFromCOMException(_context, e); } foreach (string propertyName in propertyNames) { foreach (string value in GetValuesFromCache(propertyName)) { if (!values.Contains(value)) { values.Add(value); } } } return values; }
public void AddRange (ActiveDirectorySchemaClass[] schemaClasses) { throw new NotImplementedException (); }
public void Save() { CheckIfDisposed(); if (!isBound) { try { // create a new directory entry for this class if (_schemaEntry == null) { _schemaEntry = DirectoryEntryManager.GetDirectoryEntry(_context, WellKnownDN.SchemaNamingContext); } // this will create the class and set the CN value string rdn = "CN=" + _commonName; rdn = Utils.GetEscapedPath(rdn); _classEntry = _schemaEntry.Children.Add(rdn, "classSchema"); } catch (COMException e) { throw ExceptionHelper.GetExceptionFromCOMException(_context, e); } catch (ActiveDirectoryObjectNotFoundException) { // this is the case where the context is a config set and we could not find an ADAM instance in that config set throw new ActiveDirectoryOperationException(Res.GetString(Res.ADAMInstanceNotFoundInConfigSet, _context.Name)); } // set the ldap display name property SetProperty(PropertyManager.LdapDisplayName, _ldapDisplayName); // set the oid value SetProperty(PropertyManager.GovernsID, _oid); // set the description SetProperty(PropertyManager.Description, _description); // set the possibleSuperiors property if (_possibleSuperiors != null) { _classEntry.Properties[PropertyManager.PossibleSuperiors].AddRange(_possibleSuperiors.GetMultiValuedProperty()); } // set the mandatoryProperties property if (_mandatoryProperties != null) { _classEntry.Properties[PropertyManager.MustContain].AddRange(_mandatoryProperties.GetMultiValuedProperty()); } // set the optionalProperties property if (_optionalProperties != null) { _classEntry.Properties[PropertyManager.MayContain].AddRange(_optionalProperties.GetMultiValuedProperty()); } // set the subClassOf property if (_subClassOf != null) { SetProperty(PropertyManager.SubClassOf, _subClassOf.Name); } else { // if no super class is specified, set it to "top" SetProperty(PropertyManager.SubClassOf, "top"); } // set the objectClassCategory property SetProperty(PropertyManager.ObjectClassCategory, _type); // set the schemaIDGuid property if (_schemaGuidBinaryForm != null) { SetProperty(PropertyManager.SchemaIDGuid, _schemaGuidBinaryForm); } // set the default security descriptor if (_defaultSDSddlForm != null) { SetProperty(PropertyManager.DefaultSecurityDescriptor, _defaultSDSddlForm); } } try { // commit the classEntry to server _classEntry.CommitChanges(); // Refresh the schema cache on the schema role owner if (_schema == null) { ActiveDirectorySchema schemaObject = ActiveDirectorySchema.GetSchema(_context); bool alreadyUsingSchemaRoleOwnerContext = false; DirectoryServer schemaRoleOwner = null; try { // // if we are not already talking to the schema role owner, change the context // schemaRoleOwner = schemaObject.SchemaRoleOwner; if (Utils.Compare(schemaRoleOwner.Name, _context.GetServerName()) != 0) { DirectoryContext schemaRoleOwnerContext = Utils.GetNewDirectoryContext(schemaRoleOwner.Name, DirectoryContextType.DirectoryServer, _context); _schema = ActiveDirectorySchema.GetSchema(schemaRoleOwnerContext); } else { alreadyUsingSchemaRoleOwnerContext = true; _schema = schemaObject; } } finally { if (schemaRoleOwner != null) { schemaRoleOwner.Dispose(); } if (!alreadyUsingSchemaRoleOwnerContext) { schemaObject.Dispose(); } } } _schema.RefreshSchema(); } catch (COMException e) { throw ExceptionHelper.GetExceptionFromCOMException(_context, e); } // now that the changes are committed to the server // update the defunct/non-defunct status of the class on the server _isDefunctOnServer = _isDefunct; // invalidate all properties _commonName = null; _oid = null; _description = null; _descriptionInitialized = false; _possibleSuperiors = null; _auxiliaryClasses = null; _possibleInferiors = null; _mandatoryProperties = null; _optionalProperties = null; _subClassOf = null; _typeInitialized = false; _schemaGuidBinaryForm = null; _defaultSDSddlForm = null; _defaultSDSddlFormInitialized = false; _propertiesFromSchemaContainerInitialized = false; // set bind flag isBound = true; }
public void Remove (ActiveDirectorySchemaClass schemaClass) { throw new NotImplementedException (); }
public bool Contains(ActiveDirectorySchemaClass schemaClass) { Contract.Requires(schemaClass != null); return(default(bool)); }
public void AddRange(ActiveDirectorySchemaClass[] schemaClasses) { if (schemaClasses != null) { ActiveDirectorySchemaClass[] activeDirectorySchemaClassArray = schemaClasses; int num = 0; while (num < (int)activeDirectorySchemaClassArray.Length) { ActiveDirectorySchemaClass activeDirectorySchemaClass = activeDirectorySchemaClassArray[num]; if (activeDirectorySchemaClass != null) { num++; } else { throw new ArgumentException("schemaClasses"); } } for (int i = 0; i < (int)schemaClasses.Length; i++) { this.Add(schemaClasses[i]); } return; } else { throw new ArgumentNullException("schemaClasses"); } }