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");
            }
        }
示例#15
0
        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");
            }
        }
示例#16
0
        //
        // 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);
        }
示例#17
0
 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);
        }
示例#19
0
        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);
        }
示例#20
0
        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");
     }
 }
示例#23
0
 //
 // 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 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");
			}
		}
		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);
 }
示例#32
0
 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;
 }
示例#33
0
        //
        // 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 ();
		}
示例#38
0
 public bool Contains(ActiveDirectorySchemaClass schemaClass)
 {
     throw new NotImplementedException();
 }
示例#39
0
 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;
 }
示例#43
0
 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;
 }
示例#45
0
 public void Remove(ActiveDirectorySchemaClass schemaClass)
 {
     throw new NotImplementedException();
 }
 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;
 }
        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");
			}
		}