Example #1
0
 public Resource()
 {
     Live = new PropertyValueCollection();
     Dead = new PropertyValueCollection();
     _mappings = new List<Uri>();
     CreationDate = DateTime.Now;
     UpdateDate = DateTime.Now;
 }
		public EditProcessPropertiesHelper(IWfProcess process, IWfProcessDescriptor processDesp, PropertyValueCollection properties, bool syncMSObject)
		{
			process.NullCheck("process");
			processDesp.NullCheck("processDesp");
			properties.NullCheck("properties");

			this._Process = process;
			this._ProcessDescriptor = processDesp;
			this._Properties = properties;
			this._SyncMainStream = syncMSObject;
		}
        /// <summary>
        /// 仅复制目标集合中已有的属性
        /// </summary>
        /// <param name="cpvc"></param>
        /// <param name="pvc"></param>
        public void ClientToServer(IEnumerable<ClientPropertyValue> cpvc, PropertyValueCollection pvc)
        {
            cpvc.NullCheck("cpvc");
            pvc.NullCheck("pvc");

            foreach (ClientPropertyValue cpv in cpvc)
            {
                if (pvc.ContainsKey(cpv.Key))
                    ClientPropertyValueConverter.Instance.ClientToServer(cpv, pvc[cpv.Key]);
            }
        }
Example #4
0
        private bool MatchOnPasswordSetTime(DirectoryEntry de)
        {
            PropertyValueCollection values     = de.Properties["PasswordAge"];
            Nullable <DateTime>     storeValue = null;

            if (values.Count != 0)
            {
                Debug.Assert(values.Count == 1);
                Debug.Assert(values[0] is int);

                int secondsLapsed = (int)values[0];

                storeValue = DateTime.UtcNow - new TimeSpan(0, 0, secondsLapsed);
            }

            return(TestForMatch(storeValue));
        }
        /// <summary>
        /// VerifyMsdsIsGC method is used to verify the value of options of given directory entry is even or odd.
        /// </summary>
        /// <param name="reqEntry">DirectoryEntry</param>
        /// <returns>Returns true if the options field contains odd value.</returns>
        public bool VerifyMsdsIsGC(DirectoryEntry reqEntry)
        {
            PropertyValueCollection objectClassValue = reqEntry.Properties["objectclass"];

            if (objectClassValue.Contains("nTDSDSA"))
            {
                int optionValue = (int)reqEntry.Properties["options"].Value;
                optionValue = optionValue & 1;

                if (optionValue == 1)
                {
                    return(true);
                }
            }

            if (objectClassValue.Contains("server"))
            {
                string         childDN = String.Empty;
                DirectoryEntry TN      = reqEntry.Children.Find("CN=NTDS Settings");
                childDN = TN.Properties["distinguishedname"].Value.ToString();

                if (childDN.Equals("CN=NTDS Settings," + reqEntry.Properties[StandardNames.distinguishedName].Value.ToString()))
                {
                    return(VerifyMsdsIsGC(TN));
                }
            }

            if (objectClassValue.Contains("computer"))
            {
                //Get server object with its serverReferenceBL attribute.
                DirectoryEntry TS = null;
                if (!adAdapter.GetObjectByDN(reqEntry.Properties["serverReferenceBL"].Value.ToString(), out TS))
                {
                    DataSchemaSite.Assume.IsTrue(
                        false,
                        reqEntry.Properties["serverReferenceBL"].Value.ToString()
                        + " Object is not found in server");
                }

                if (TS != null)
                {
                    return(VerifyMsdsIsGC(TS));
                }
            }
            return(false);
        }
Example #6
0
        static internal void MultiStringToDirectoryEntryConverter(Principal p, string propertyName, DirectoryEntry de, string suggestedProperty)
        {
            PrincipalValueCollection <string> trackingList = (PrincipalValueCollection <string>)p.GetValueForProperty(propertyName);

            if (p.unpersisted && trackingList == null)
            {
                return;
            }

            List <string> insertedValues = trackingList.Inserted;
            List <string> removedValues  = trackingList.Removed;
            List <Pair <string, string> > changedValues = trackingList.ChangedValues;

            PropertyValueCollection properties = de.Properties[suggestedProperty];

            // We test to make sure the change hasn't already been applied to the PropertyValueCollection,
            // because PushChangesToNative can be called multiple times prior to committing the changes and
            // we want to maintain idempotency
            foreach (string value in removedValues)
            {
                if (value != null && properties.Contains(value))
                {
                    properties.Remove(value);
                }
            }

            foreach (Pair <string, string> changedValue in changedValues)
            {
                // Remove the original value and add in the new value
                Debug.Assert(changedValue.Left != null);    // since it came from the system
                properties.Remove(changedValue.Left);

                if (changedValue.Right != null && !properties.Contains(changedValue.Right))
                {
                    properties.Add(changedValue.Right);
                }
            }

            foreach (string value in insertedValues)
            {
                if (value != null && !properties.Contains(value))
                {
                    properties.Add(value);
                }
            }
        }
Example #7
0
        private void PrintProperties(SearchResult res)
        {
            DirectoryEntry ent = res.GetDirectoryEntry();

            Console.WriteLine("Properties of {0}", ent.Name);
            Console.WriteLine("Path: {0}", ent.Path);
            foreach (string name in ent.Properties.PropertyNames)
            {
                Console.Write("\t{0} Value: ", name);
                PropertyValueCollection valuecoll = ent.Properties[name];
                foreach (object obj in valuecoll)
                {
                    Console.Write("\t{0} ", obj);
                }
                Console.WriteLine("");
            }
        }
		public void PropertyValueCollectionSerializeTest()
		{
			PropertyValueCollection pvc = new PropertyValueCollection();

			pvc.Add(PreparePropertyValue());

			XElementFormatter formatter = new XElementFormatter();

			XElement root = formatter.Serialize(pvc);

			Console.WriteLine(root.ToString());

			PropertyValueCollection newPvc = (PropertyValueCollection)formatter.Deserialize(root);

			Assert.AreEqual(pvc.Count, newPvc.Count);
			Assert.AreEqual(pvc[0].StringValue, newPvc[pvc[0].Definition.Name].StringValue);
		}
Example #9
0
        private string tryGetUserDepartment(UserPrincipal principal)
        {
            DirectoryEntry directoryEntry = principal.GetUnderlyingObject() as DirectoryEntry;

            if (directoryEntry != null)
            {
                if (directoryEntry.Properties.Contains("department"))
                {
                    PropertyValueCollection propertyValueCollection = directoryEntry.Properties["department"];
                    if (propertyValueCollection.Count > 0)
                    {
                        return(propertyValueCollection[0].ToString());
                    }
                }
            }
            return(string.Empty);
        }
        /// <summary>
        /// Retrieves the Central Access Rules for the Central Policy
        /// </summary>
        /// <param name="capId">Unique Identifier for the Central Policy</param>
        /// <returns>A Dictionary of CAR names and the Central Access Rule object</returns>
        public Dictionary <string, CentralAccessRule> FetchCentralAccessRules(SecurityIdentifier capId)
        {
            Dictionary <string, CentralAccessRule> carInfo = null;

            if (CapCount == 0 || !availableCaps.Contains(capId))
            {
                return(null);
            }

            using (var CapContainer = new DirectoryEntry("LDAP://" + capContainerDN))
            {
                foreach (DirectoryEntry capEntry in CapContainer.Children)
                {
                    var entryId = capEntry.Properties["msAuthz-CentralAccessPolicyID"].Value;

                    if (entryId == null)
                    {
                        continue;
                    }

                    byte[] rawCapId = entryId as byte[];
                    if (rawCapId == null)
                    {
                        continue;
                    }

                    var entrySid = new SecurityIdentifier(rawCapId, 0);

                    if (capId == entrySid)
                    {
                        PropertyValueCollection CARs = capEntry.Properties["msAuthz-MemberRulesInCentralAccessPolicy"];

                        carInfo = new Dictionary <string, CentralAccessRule>(CARs.Count);

                        foreach (string carDN in CARs)
                        {
                            CentralAccessRule CAR = new CentralAccessRule(carDN);
                            carInfo.Add(CAR.Name, CAR);
                        }
                    }
                }
            }

            return(carInfo);
        }
Example #11
0
        public string RemoveHostHeader(string websiteName, string ipAddress, string port, string hostname)
        {
            string         websiteID   = GetWebsiteID(websiteName);
            string         websitePath = "IIS://" + mServer + "/w3svc/" + websiteID;
            DirectoryEntry website     = null;

            try
            {
                website = new DirectoryEntry(websitePath);
            }
            catch (Exception error)
            {
                throw new Exception("Error creating the web directory entry.\n" + error.Message + "\n" + error.InnerException);
            }

            PropertyValueCollection websiteBindings = null;

            try
            {
                websiteBindings = website.Properties["ServerBindings"];
            }
            catch (Exception error)
            {
                throw new Exception("Error getting the host header listing.\n" + error.Message + "\n" + error.InnerException);
            }

            string hostHeader = string.Format("{0}:{1}:{2}", ipAddress, port, hostname);

            if (!websiteBindings.Contains(hostHeader))
            {
                return("missing");
            }

            try
            {
                websiteBindings.Remove(hostHeader);
                website.CommitChanges();
            }
            catch (System.Exception error)
            {
                throw new Exception("Error removing the host header.\n" + error.Message + "\n" + error.InnerException);
            }

            return("removed");
        }
Example #12
0
        private static string GetDomainName(DirectoryEntry directoryEntry)
        {
            PropertyValueCollection propertyValueCollection = directoryEntry.Properties[ActiveDirectoryProperties.DistinguishedName];

            if (propertyValueCollection != null)
            {
                string distinguishedName = Convert.ToString(propertyValueCollection.Value);

                string firstDcElement = distinguishedName.Split(',').FirstOrDefault(x => x.StartsWith("DC=", StringComparison.InvariantCultureIgnoreCase));

                if (!string.IsNullOrEmpty(firstDcElement))
                {
                    return(firstDcElement.Split('=')[1]);
                }
            }

            return(null);
        }
Example #13
0
        /// <summary>
        /// 用户是否属于某个组
        /// </summary>
        /// <param name="accountName">用户登录名称,不包括域名 如:xueqingxia</param>
        /// <param name="groupName">组名 如:英语0901</param>
        /// <returns></returns>
        public static bool UserIsMemberof(string accountName, string groupName)
        {
            DirectoryEntry user = GetDirectoryEntryByAccount(accountName);

            if (user != null)
            {
                System.DirectoryServices.PropertyCollection props = user.Properties;
                PropertyValueCollection values = props["memberOf"];
                foreach (object val in values)
                {
                    if (val.ToString().ToLower().Contains(groupName.ToLower()))
                    {
                        return(true);
                    }
                }
            }
            return(false);
        }
        private static PropertyValueCollection PrepareProperties()
        {
            PropertyValueCollection properties = new PropertyValueCollection();

            PropertyDefine pd1 = new PropertyDefine();

            pd1.Name = "P1";

            properties.Add(new PropertyValue(pd1));

            PropertyDefine pd2 = new PropertyDefine();

            pd2.Name = "P2";

            properties.Add(new PropertyValue(pd2));

            return(properties);
        }
Example #15
0
        private string getPropertyValue(PropertyCollection propertyCollection, string propertyName)
        {
            PropertyValueCollection ValueCollection = propertyCollection[propertyName];
            var value = "";

            for (int i = 0; i < ValueCollection.Count; i++)
            {
                if (i == 0)
                {
                    value = ValueCollection[i].ToString();
                }
                else
                {
                    value = value + "|" + ValueCollection[i].ToString();
                }
            }
            return(value);
        }
Example #16
0
        /*
         * /// <summary>
         * /// creates and returns a connector attribute or null.  the attribute
         * /// has the name 'name' and the values associated with 'name' in the
         * /// directory entry
         * /// </summary>
         * /// <param name="name"></param>
         * /// <param name="pvc"></param>
         * /// <returns></returns>
         * private static ConnectorAttribute CreateConnectorAttribute(String name,
         *  PropertyValueCollection pvc)
         * {
         *  ConnectorAttributeBuilder attributeBuilder = new ConnectorAttributeBuilder();
         *
         *  if (name == null)
         *  {
         *      return null;
         *  }
         *
         *  attributeBuilder.Name = name;
         *
         *  if (pvc == null)
         *  {
         *      attributeBuilder.AddValue(null);
         *  }
         *  else
         *  {
         *      for (int i = 0; i < pvc.Count; i++)
         *      {
         *          Object valueObject = pvc[i];
         *          if ((pvc[i] == null) ||
         *              (FrameworkUtil.IsSupportedAttributeType(valueObject.GetType())))
         *          {
         *              attributeBuilder.AddValue(pvc[i]);
         *          }
         *          else
         *          {
         *              Trace.TraceWarning(
         *                  "Unsupported attribute type ... calling ToString (Name: \'{0}\'({1}) Type: \'{2}\' String Value: \'{3}\'",
         *                  name, i, pvc[i].GetType(), pvc[i].ToString());
         *              attributeBuilder.AddValue(pvc[i].ToString());
         *          }
         *      }
         *  }
         *
         *  return attributeBuilder.Build();
         * }
         *
         * private static void AddConnectorAttributeToADProperties_general(
         *  PropertyCollection properties,
         *  ConnectorAttribute attribute, UpdateType type)
         * {
         *  // null out the values if we are deleting
         *  // or replacing attributes.
         *  if (type.Equals(UpdateType.DELETE) ||
         *      type.Equals(UpdateType.REPLACE))
         *  {
         *      properties[attribute.Name].Value = null;
         *  }
         *
         *  // if we are updating or adding, put the
         *  // new values in.
         *  if (type.Equals(UpdateType.ADD) ||
         *      type.Equals(UpdateType.REPLACE))
         *  {
         *      foreach (Object valueObject in attribute.Value)
         *      {
         *          properties[attribute.Name].Add(valueObject);
         *      }
         *  }
         * }
         */

        /// <summary>
        /// Gets a single value from a propertyvaluecollection
        /// for a particular property name.  Its an error if the
        /// property contains multiple values.
        /// </summary>
        /// <param name="pvc"></param>
        /// <returns></returns>
        internal Object GetSingleValue(PropertyValueCollection pvc)
        {
            if ((pvc == null) || (pvc.Count == 0))
            {
                return(null);
            }

            if (pvc.Count > 1)
            {
                String msg = _configuration.ConnectorMessages.Format(
                    "ex_ExpectingSingleValue",
                    "Expecting single value, but found multiple values for attribute {0}",
                    pvc.PropertyName);
                throw new ConnectorException(msg);
            }

            return(pvc[0]);
        }
Example #17
0
        /// <summary>
        /// 获取属性值的合并字符串。
        /// </summary>
        /// <param name="propertyName">表示属性名称。</param>
        /// <param name="delimiter">表示属性值分隔符。</param>
        /// <returns>返回属性值字符串。</returns>
        public string GetPropertyValuesToString(string propertyName, char delimiter)
        {
            string values = string.Empty;

            if (this.Properties.Contains(propertyName))
            {
                PropertyValueCollection propertyValueCollection = Properties[propertyName];
                for (int i = 0; i < propertyValueCollection.Count; i++)
                {
                    values += propertyValueCollection[i].ToString();
                    if (i + 1 < propertyValueCollection.Count)
                    {
                        values += delimiter;
                    }
                }
            }
            return(values);
        }
Example #18
0
        private IEnumerable <string> GetSchemaProperties(string schemaNamingContext, string objectType)
        {
            IEnumerable <string> data;

            using (var de = new DirectoryEntry())
            {
                de.Username = _username;
                de.Password = _password;

                de.Path = String.Format("LDAP://{0}CN={1},{2}", _hostname, objectType, schemaNamingContext);

                PropertyValueCollection values = de.Properties["systemMayContain"];
                data = from s in values.Cast <string>()
                       orderby s
                       select s;
            }
            return(data);
        }
Example #19
0
        private static Dictionary <string, object> GetAdditionalProperties(DirectoryEntry directoryEntry, IEnumerable <string> additionalPropertyNames)
        {
            var results = new Dictionary <string, object>();

            if (additionalPropertyNames != null)
            {
                foreach (string propertyName in additionalPropertyNames)
                {
                    PropertyValueCollection propertyValueCollection = directoryEntry.Properties[propertyName];
                    if (propertyValueCollection != null)
                    {
                        results.Add(propertyName, propertyValueCollection.Value);
                    }
                }
            }

            return(results);
        }
Example #20
0
 static SaltarelleController()
 {
     try {
         using (var entry = new DirectoryEntry("IIS://localhost/MimeMap")) {
             PropertyValueCollection properties = entry.Properties["MimeMap"];
             mimeMap = properties.Cast <object>().ToDictionary(x => ((string)x.GetType().InvokeMember("Extension", BindingFlags.GetProperty, null, x, null)).ToLowerInvariant(), x => (string)x.GetType().InvokeMember("MimeType", BindingFlags.GetProperty, null, x, null));
         }
     }
     catch (Exception) {
         // Something is probably wrong with IIS (not installed/not working/whatever. No big deal, just use the map from the registry instead if developing.
         mimeMap = (from key in Registry.ClassesRoot.GetSubKeyNames()
                    where key.StartsWith(".")
                    let value = Registry.GetValue("HKEY_CLASSES_ROOT\\" + key, "Content Type", null) as string
                                where !string.IsNullOrEmpty(value)
                                select new { key, value }
                    ).ToDictionary(x => x.key.ToLowerInvariant(), x => x.value);
     }
 }
Example #21
0
        /// <summary>
        /// Gets a list of websites on an IIS Server
        /// </summary>
        /// <param name="server">A list of IISWebsite information objects</param>
        /// <returns>list of websites on an IIS Server in the form of IIsWebsiteInfo objects</returns>
        public static List <IIsWebsiteInfo> GetWebsitesOnIISServer(string server)
        {
            List <IIsWebsiteInfo> webSites = new List <IIsWebsiteInfo>();
            DirectoryEntry        W3SVC    = new DirectoryEntry(string.Format("IIS://{0}/W3SVC", server));

            foreach (DirectoryEntry Site in W3SVC.Children)
            {
                if (0 == string.Compare(Site.SchemaClassName, "IIsWebServer"))
                {
                    IIsWebsiteInfo webSite = new IIsWebsiteInfo();
                    webSite.WebsiteID = Site.Name;
                    string serverComment = Convert.ToString(Site.Properties["ServerComment"].Value);
                    if (!string.IsNullOrEmpty(serverComment))
                    {
                        webSite.FriendlyName = serverComment;
                    }
                    List <string>           ports       = new List <string>();
                    PropertyValueCollection bindings    = Site.Properties["ServerBindings"];
                    PropertyValueCollection bindingsSSL = Site.Properties["SecureBindings"];
                    if (bindings != null)
                    {
                        foreach (object binding in bindings)
                        {
                            ports.Add((string)binding);
                        }
                    }
                    if (bindingsSSL != null)
                    {
                        webSite.UsingSSL = true;
                        foreach (object binding in bindingsSSL)
                        {
                            ports.Add((string)binding);
                        }
                    }
                    webSite.Ports = new List <string>();
                    foreach (string port in ports)
                    {
                        webSite.Ports.Add(port);
                    }
                    webSites.Add(webSite);
                }
            }
            return(webSites);
        }
 protected override void PreDeleteFromMetabase()
 {
     if (!DirectoryEntry.Exists(base.DataObject.MetabasePath))
     {
         return;
     }
     using (DirectoryEntry directoryEntry = IisUtility.CreateIISDirectoryEntry(base.DataObject.MetabasePath, new Task.TaskErrorLoggingReThrowDelegate(this.WriteError), this.Identity))
     {
         PropertyValueCollection propertyValueCollection = directoryEntry.Properties["ScriptMaps"];
         foreach (object obj in propertyValueCollection)
         {
             string   text  = (string)obj;
             string[] array = text.Split(new char[]
             {
                 ','
             });
             if (array.Length >= 2)
             {
                 string fileName = Path.GetFileName(array[1]);
                 if (string.Compare(fileName, "davex.dll", true, CultureInfo.InvariantCulture) == 0 || string.Compare(fileName, "exprox.dll", true, CultureInfo.InvariantCulture) == 0)
                 {
                     this.scriptMapPhysicalPath = array[1];
                     break;
                 }
             }
         }
         try
         {
             string parent = null;
             string text2  = null;
             string name   = null;
             IisUtility.ParseApplicationRootPath(directoryEntry.Path, ref parent, ref text2, ref name);
             if (IisUtility.Exists(parent, name, "IIsWebVirtualDir"))
             {
                 OwaVirtualDirectoryHelper.DisableIsapiFilter(base.DataObject);
             }
         }
         catch (Exception)
         {
             this.WriteWarning(Strings.OwaMetabaseIsapiUninstallFailure);
             throw;
         }
     }
 }
Example #23
0
        private IEnumerator GetNextChunk()
        {
            IEnumerator enumerator;

            object[] objArray = new object[2];
            objArray[0] = this.propertyName;
            objArray[1] = this.lowRange;
            string str = string.Format(CultureInfo.InvariantCulture, "{0};range={1}-*", objArray);

            try
            {
                string[] strArrays = new string[2];
                strArrays[0] = str;
                strArrays[1] = this.propertyName;
                this.de.RefreshCache(strArrays);
                goto Label0;
            }
            catch (COMException cOMException1)
            {
                COMException cOMException = cOMException1;
                if (cOMException.ErrorCode != -2147016672)
                {
                    throw;
                }
                else
                {
                    enumerator = null;
                }
            }
            return(enumerator);

Label0:
            PropertyValueCollection item = this.de.Properties[this.propertyName];

            if (item == null || item.Count == 0)
            {
                return(null);
            }
            else
            {
                this.lowRange = this.lowRange + item.Count;
                return(item.GetEnumerator());
            }
        }
Example #24
0
        public static bool CheckComputerSecurityGroup(string computerName, string groupNames, string domain)
        {
            List <string> groupName = groupNames.ToUpper().Split(',').ToList();
            List <string> groups    = new List <string>();

            PrincipalContext  domainContext = new PrincipalContext(ContextType.Domain);
            ComputerPrincipal computer      = ComputerPrincipal.FindByIdentity(domainContext, computerName);

            using (var directoryEntry = new DirectoryEntry("LDAP://" + computer.DistinguishedName))
            {
                PropertyValueCollection ValueCollection = directoryEntry.Properties["memberOf"];
                IEnumerator             en = ValueCollection.GetEnumerator();
                while (en.MoveNext())
                {
                    if (en.Current != null)
                    {
                        string group = en.Current.ToString().Substring(3, (en.Current.ToString()).IndexOf(',') - 3);
                        if (!groups.Contains(group))
                        {
                            groups.Add(group);
                            //if (recursive)
                            //AttributeValuesMultiString(attributeName, en.Current.ToString(), valuesCollection, true);
                        }
                    }
                }
            }

            foreach (string name in groupName)
            {
                Console.WriteLine("\t{0}", name);
            }

            foreach (string g in groups)
            {
                string query = groupName.Find(group => group == g.ToUpper());
                if (query != null)
                {
                    return(true);
                }
            }

            return(false);
        }
Example #25
0
        // generically set a value in the uac to the value of 'isSet'
        internal static void Set(PropertyValueCollection pvc, int flag, bool?isSet)
        {
            int uac = GetUAC(pvc);

            if (isSet == null)
            {
                throw new ArgumentException();
            }
            // boolean false
            if (isSet.Value.Equals(false))
            {
                uac &= (~flag);
            }
            else
            {
                uac |= flag;
            }
            SetUAC(pvc, uac);
        }
Example #26
0
        private static List <string> GetChildDomainPaths(DirectoryEntry directoryEntry)
        {
            var memberPaths = new List <string>();
            PropertyValueCollection memberValueCollection = directoryEntry.Properties[ActiveDirectoryProperties.Member];

            if (memberValueCollection != null)
            {
                IEnumerator memberEnumerator = memberValueCollection.GetEnumerator();
                while (memberEnumerator.MoveNext())
                {
                    if (memberEnumerator.Current != null)
                    {
                        memberPaths.Add(AdDomainPathHandler.Escape(memberEnumerator.Current.ToString()));
                    }
                }
            }

            return(memberPaths);
        }
Example #27
0
        private void InitializeDirectReports()
        {
            if (UserEntry != null)
            {
                PropertyValueCollection reports = UserEntry.Properties["directReports"];
                foreach (string report in reports)
                {
                    FullyQualifiedADName adName = GetADNameFromDescriptor(report);

                    UserInformation uiReport = new UserInformation();
                    if (!uiReport.InitializeWithFullName(adName.Name, adName.DomainName))
                    {
                        Planner.Instance.WriteToEventLog("Updating team members: fullname did not resolve: " + adName.Name);
                    }

                    DirectReports.Add(uiReport);
                }
            }
        }
        /// <summary>
        /// Users the can write.
        /// </summary>
        /// <param name="entity">The entity.</param>
        /// <returns></returns>
        private bool CanUserWrite(AssignmentEntity entity)
        {
            if (entity.WorkflowInstanceId.HasValue &&
                !string.IsNullOrEmpty(entity.WorkflowActivityName))
            {
                PropertyValueCollection properties = WorkflowActivityWrapper.GetAssignmentProperties((Guid)entity.WorkflowInstanceId.Value, entity.WorkflowActivityName);

                if (properties.Contains(AssignmentCustomProperty.ReadOnlyLibraryAccess))
                {
                    bool?value = properties[AssignmentCustomProperty.ReadOnlyLibraryAccess] as bool?;
                    if (value.HasValue)
                    {
                        return(!value.Value);
                    }
                }
            }

            return(true);
        }
Example #29
0
 private static bool CheckEquals(PropertyValueCollection properties, string[] values)
 {
     if (values == null)
     {
         return(properties.Count == 0);
     }
     if (properties.Count != values.Length)
     {
         return(false);
     }
     foreach (var v in values)
     {
         if (!properties.Contains(v))
         {
             return(false);
         }
     }
     return(true);
 }
Example #30
0
        public void ValidatorParamsToProperties()
        {
            ValidatorSettings settings = ValidatorSettings.GetConfig();

            foreach (ValidatorTypeConfigurationElement element in settings.Validators)
            {
                Console.WriteLine("Name: {0}, Type: {1}", element.Name, element.Type);

                PropertyValueCollection properties = element.ToPropertyValues();

                if (properties.Count > 0)
                {
                    foreach (PropertyValue pv in properties)
                    {
                        Console.WriteLine("Name: {0}, Type: {1}", pv.Definition.Name, pv.Definition.DataType);
                    }
                }
            }
        }
        public static List <string> GetPropertyValues(string name, object values)
        {
            List <string> propValues = new List <string>();

            PropertyValueCollection pvc       = (PropertyValueCollection)values;
            IEnumerator             pvcValues = pvc.GetEnumerator();

            while (pvcValues.MoveNext())
            {
                Type   type     = pvcValues.Current.GetType();
                String valueStr = GetPropertyValueString(pvcValues.Current);
                if (valueStr != null)
                {
                    propValues.Add(valueStr);
                }
            }

            return(propValues);
        }
Example #32
0
        public void PropertyValueValidatorTest()
        {
            PropertyGroupConfigurationElementCollection groups = PropertyGroupSettings.GetConfig().Groups;

            foreach (PropertyGroupConfigurationElement group in groups)
            {
                PropertyDefineCollection propertiesDefinitions = new PropertyDefineCollection();

                propertiesDefinitions.LoadPropertiesFromConfiguration(group);

                PropertyValueCollection properties = new PropertyValueCollection();

                properties.AppendFromPropertyDefineCollection(propertiesDefinitions);

                ValidationResults results = properties.Validate();

                Console.WriteLine(results.ToString("\r\n"));
            }
        }
Example #33
0
        //public static List<string> GetAppPools2()
        //{
        //    DirectoryEntry dir = new DirectoryEntry("IIS://localhost/w3svc/AppPools");
        //    List<string> list = new List<string>();
        //    foreach (DirectoryEntry child in dir.Children)
        //    {
        //        list.Add(child.Name);
        //    }
        //    return list;
        //}

        //public static List<string> GetAppPools()
        //{
        //    Comm.MetaBaseSave();
        //    List<string> list = new List<string>();
        //    string MetaBase = File.ReadAllText(Comm.MetaBasePath());
        //    foreach (Match item in Regex.Matches(MetaBase, @"/LM/W3SVC/AppPools/(.+?)"""))
        //    {
        //        list.Add(item.Groups[1].Value);
        //    }
        //    return list;
        //}



        #endregion


        #region Attributes
        public static string GetPropertyValue(DirectoryEntry dir, string Properties)
        {
            string split = "柳永法";
            PropertyValueCollection s = dir.Properties[Properties];

            if (s.Count == 0)
            {
                return(s[0].ToString());
            }
            else
            {
                string temp = "";
                for (int i = 0; i < s.Count; i++)
                {
                    temp += split + s[i].ToString();
                }
                return(temp.Substring(split.Length));
            }
        }
Example #34
0
        private static void UpdateMetaBaseProperty(DirectoryEntry entry, string metaBasePropertyName, string metaBaseProperty)
        {
            if (metaBaseProperty.IndexOf('|') == -1)
            {
                string propertyTypeName = (string)new DirectoryEntry(entry.SchemaEntry.Parent.Path + "/" + metaBasePropertyName).Properties["Syntax"].Value;
                if (string.Compare(propertyTypeName, "binary", StringComparison.OrdinalIgnoreCase) == 0)
                {
                    object[] metaBasePropertyBinaryFormat = new object[metaBaseProperty.Length / 2];
                    for (int i = 0; i < metaBasePropertyBinaryFormat.Length; i++)
                    {
                        metaBasePropertyBinaryFormat[i] = metaBaseProperty.Substring(i * 2, 2);
                    }

                    PropertyValueCollection propValues = entry.Properties[metaBasePropertyName];
                    propValues.Clear();
                    propValues.Add(metaBasePropertyBinaryFormat);
                    entry.CommitChanges();
                }
                else
                {
                    if (string.Compare(metaBasePropertyName, "path", StringComparison.OrdinalIgnoreCase) == 0)
                    {
                        DirectoryInfo f = new DirectoryInfo(metaBaseProperty);
                        metaBaseProperty = f.FullName;
                    }

                    entry.Invoke("Put", metaBasePropertyName, metaBaseProperty);
                    entry.Invoke("SetInfo");
                }
            }
            else
            {
                entry.Invoke("Put", metaBasePropertyName, string.Empty);
                entry.Invoke("SetInfo");
                string[] metabaseProperties = metaBaseProperty.Split('|');
                foreach (string metabasePropertySplit in metabaseProperties)
                {
                    entry.Properties[metaBasePropertyName].Add(metabasePropertySplit);
                }

                entry.CommitChanges();
            }
        }
Example #35
0
        private void RePrepare(PropertyValueCollection propVals)
        {
            //If empty go for full rebuild
            if (propVals.Count == 0)
            {
                propertySnapshot = null;
                Prepare(propVals);
                return;
            }

            //Otherwise purge from the property values any properties not 
            //in the snapshot
            List<PropertyValue> remove = new List<PropertyValue>();
            foreach (PropertyValue p in propVals)
            {
                if (!propertySnapshot.Contains(p.Name.Name))
                    remove.Add(propVals.FindItem(p.Name.Name));
            }
            if (remove.Count > 0)
            {
                foreach (PropertyValue propVal in remove)
                {
                    propVals.Remove(propVal);
                }
            }

            currentValues.Clear();
            //Re-cache property values into temp dictionary
            foreach (PropertyValue p in propVals)
            {
                currentValues[p.Name.Name] = p.Value as LiteralValue;
            }
        }
Example #36
0
        private void Prepare(PropertyValueCollection propVals)
        {
            propVals.Clear();
            currentValues.Clear();

            // I do not trust the long-term stability of the PropertyValueCollection
            //
            // So what we do is load it up once with LiteralValue references and manipulate these
            // outside of the collection (via a cached dictionary). We cache everything from the wrapper API 
            // that can be cached in the managed world so that we only have minimal contact with it

            // Omit read-only properties
            using (FdoFeatureService service = _conn.CreateFeatureService())
            {
                ClassDefinition c = service.GetClassByName(this.ClassName);
                foreach (PropertyDefinition p in c.Properties)
                {
                    string name = p.Name;
                    PropertyValue pv = new PropertyValue(name, null);
                    if (p.PropertyType == PropertyType.PropertyType_DataProperty)
                    {
                        DataPropertyDefinition d = p as DataPropertyDefinition;
                        if (!d.ReadOnly && !d.IsAutoGenerated) 
                        {
                            DataValue dv = null;
                            switch (d.DataType)
                            {
                                case DataType.DataType_BLOB:
                                    dv = new BLOBValue();
                                    break;
                                case DataType.DataType_Boolean:
                                    dv = new BooleanValue();
                                    break;
                                case DataType.DataType_Byte:
                                    dv = new ByteValue();
                                    break;
                                case DataType.DataType_CLOB:
                                    dv = new CLOBValue();
                                    break;
                                case DataType.DataType_DateTime:
                                    dv = new DateTimeValue();
                                    break;
                                case DataType.DataType_Decimal:
                                    dv = new DecimalValue();
                                    break;
                                case DataType.DataType_Double:
                                    dv = new DoubleValue();
                                    break;
                                case DataType.DataType_Int16:
                                    dv = new Int16Value();
                                    break;
                                case DataType.DataType_Int32:
                                    dv = new Int32Value();
                                    break;
                                case DataType.DataType_Int64:
                                    dv = new Int64Value();
                                    break;
                                case DataType.DataType_Single:
                                    dv = new SingleValue();
                                    break;
                                case DataType.DataType_String:
                                    dv = new StringValue();
                                    break;
                            }
                            if (dv != null)
                            {
                                pv.Value = dv;
                                propVals.Add(pv);
                            }
                        }
                    }
                    else if (p.PropertyType == PropertyType.PropertyType_GeometricProperty)
                    {
                        GeometricPropertyDefinition g = p as GeometricPropertyDefinition;
                        if (!g.ReadOnly)
                        {
                            GeometryValue gv = new GeometryValue();
                            pv.Value = gv;
                            propVals.Add(pv);
                        }
                    }
                }
                c.Dispose();
            }

            //Load property values into temp dictionary
            foreach (PropertyValue p in propVals)
            {
                currentValues[p.Name.Name] = p.Value as LiteralValue;
            }

            if (propertySnapshot == null)
            {
                propertySnapshot = new List<string>();
                foreach (PropertyValue p in propVals)
                {
                    propertySnapshot.Add(p.Name.Name);
                }
            }
        }
Example #37
0
 public static string GetGroupCategory(PropertyValueCollection ADgrptype)
 {
     // Source: https://msdn.microsoft.com/en-us/library/ms675935(v=vs.85).aspx
     Int32 grouptype = 0;
     if (ADgrptype != null)
         grouptype = (Int32)ADgrptype.Value;
     string GroupCategory = "Distribution";
     if ((grouptype & 0x80000000) > 0)
         GroupCategory = "Security";
     return GroupCategory;
 }
        /// <summary>
        /// 初始化一个基本的属性集合,包括Key、Name、Description、Enabled几个基本属性
        /// </summary>
        /// <returns></returns>
        private static PropertyValueCollection PrepareServerProperties()
        {
            PropertyValueCollection properties = new PropertyValueCollection();

            PropertyDefineCollection definitions = new PropertyDefineCollection();

            definitions.LoadPropertiesFromConfiguration(WfActivitySettings.GetConfig().PropertyGroups["AllDescriptorProperties"]);

            properties.InitFromPropertyDefineCollection(definitions);

            return properties;
        }
        //活动矩阵定义的属性优先于活动模板定义的属性,矩阵中没有设置的属性,则使用活动模版的属性
        private static void MergeDynamicActivitiesProperties(WfCreateActivityParamCollection createActivityParams, IWfActivityDescriptor templateActDesp)
        {
            foreach (WfCreateActivityParam cap in createActivityParams)
            {
                PropertyValueCollection templateProperties = new PropertyValueCollection();

                foreach (PropertyValue pv in templateActDesp.Properties)
                {
                    if (cap.RoleDefineActivityPropertyNames.Exists(name => pv.Definition.Name == name))
                    {
                        if (cap.Template.Properties.ContainsKey(pv.Definition.Name))
                            templateProperties.Add(cap.Template.Properties[pv.Definition.Name]);
                    }
                    else
                        templateProperties.Add(pv);
                }

                cap.Template.Properties.ReplaceExistedPropertyValues(templateProperties);

                cap.Template.RelativeLinks.Clear();
                cap.Template.RelativeLinks.CopyFrom(templateActDesp.RelativeLinks);

                cap.Template.Variables.Clear();
                cap.Template.Variables.CopyFrom(templateActDesp.Variables);

                //cap.Template.EnterEventReceivers.Clear();
                cap.Template.EnterEventReceivers.CopyFrom(templateActDesp.EnterEventReceivers);

                //cap.Template.LeaveEventReceivers.Clear();
                cap.Template.LeaveEventReceivers.CopyFrom(templateActDesp.LeaveEventReceivers);

                cap.Template.EnterEventExecuteServices.Clear();
                cap.Template.EnterEventExecuteServices.CopyFrom(templateActDesp.EnterEventExecuteServices);

                cap.Template.LeaveEventExecuteServices.Clear();
                cap.Template.LeaveEventExecuteServices.CopyFrom(templateActDesp.LeaveEventExecuteServices);

                cap.Template.WithdrawExecuteServices.Clear();
                cap.Template.WithdrawExecuteServices.CopyFrom(templateActDesp.WithdrawExecuteServices);

                cap.Template.BeWithdrawnExecuteServices.Clear();
                cap.Template.BeWithdrawnExecuteServices.CopyFrom(templateActDesp.BeWithdrawnExecuteServices);
            }
        }
 private static void OutputServerProperties(PropertyValueCollection spc)
 {
     spc.ForEach(pv => Console.WriteLine("{0}: {1}", pv.Definition.Name, pv.StringValue));
 }
Example #41
0
 public static string GetGroupScope(PropertyValueCollection ADgrptype)
 {
     // Source: https://msdn.microsoft.com/en-us/library/ms675935(v=vs.85).aspx
     Int32 grouptype = 0;
     if (ADgrptype != null)
         grouptype = (Int32)ADgrptype.Value;
     string GroupScope = "";
     if ((grouptype & 0x1) == 0x1)
         GroupScope = "BuiltIn";
     else if ((grouptype & 0x2) == 0x2)
         GroupScope = "Global";
     else if ((grouptype & 0x4) == 0x4)
         GroupScope = "DomainLocal";
     else if ((grouptype & 0x8) == 0x8)
         GroupScope = "Universal";
     return GroupScope;
 }
Example #42
0
    public static void SaveGroupMembersToXml(XmlDocument doc, XmlElement body, string ParentDS,
        PropertyValueCollection GroupMembers)
    {
        try
        {
            XmlElement group = doc.CreateElement(string.Empty, "Group", string.Empty);
            group.SetAttribute("GrpDS", ParentDS);
            body.AppendChild(group);

            foreach (Object obj in GroupMembers)
            {
                string GrpMember = (string)obj;
                XmlElement member = doc.CreateElement(string.Empty, "Member", string.Empty);
                member.SetAttribute("MemberDS", GrpMember);
                group.AppendChild(member);
            }
        }
        catch (Exception ex)
        {
            SqlContext.Pipe.Send("Warning: SaveGroupMembersToXml (" + ParentDS + ") failed. Exception: " + ex.Message);
        }
    }
 public void CopyTo(PropertyValueCollection[] array, int index)
 {
 }
		public void PropertyValueValidatorTest()
		{
			PropertyGroupConfigurationElementCollection groups = PropertyGroupSettings.GetConfig().Groups;

			foreach (PropertyGroupConfigurationElement group in groups)
			{
				PropertyDefineCollection propertiesDefinitions = new PropertyDefineCollection();

				propertiesDefinitions.LoadPropertiesFromConfiguration(group);

				PropertyValueCollection properties = new PropertyValueCollection();

				properties.AppendFromPropertyDefineCollection(propertiesDefinitions);

				ValidationResults results = properties.Validate();

				Console.WriteLine(results.ToString("\r\n"));
			}
		}
Example #45
0
        public static IPropertyValueCollection GetStaticProperties(this IResource resource)
        {
            var result = new PropertyValueCollection();
            var prop = new Property();
            prop.Name = "creationdate";
            prop.PropertyType = typeof(DateTime);
            var value = new PropertyValue();
            value.Property = prop;
            value.Value = resource.CreationDate;
            result.Add(value);

            prop = new Property();
            prop.Name = "displayname";
            prop.PropertyType = typeof(string);
            value = new PropertyValue();
            value.Property = prop;
            value.Value = resource.DisplayName;
            result.Add(value);

            prop = new Property();
            prop.Name = "getcontentlanguage";
            prop.PropertyType = typeof(string);
            value = new PropertyValue();
            value.Property = prop;
            value.Value = resource.DisplayName;
            result.Add(value);

            prop = new Property();
            prop.Name = "getcontentlength";
            prop.PropertyType = typeof(int);
            value = new PropertyValue();
            value.Property = prop;
            value.Value = resource.ContentLength;
            result.Add(value);

            prop = new Property();
            prop.Name = "getcontenttype";
            prop.PropertyType = typeof(string);
            value = new PropertyValue();
            value.Property = prop;
            value.Value = resource.ContentType;
            result.Add(value);

            prop = new Property();
            prop.Name = "getetag";
            prop.PropertyType = typeof(string);
            value = new PropertyValue();
            value.Property = prop;
            value.Value = resource.ETag;
            result.Add(value);

            prop = new Property();
            prop.Name = "getlastmodified";
            prop.PropertyType = typeof(string);
            value = new PropertyValue();
            value.Property = prop;
            value.Value = resource.LastModified;
            result.Add(value);

            prop = new Property();
            prop.Name = "lockdiscovery";
            prop.PropertyType = typeof(int);
            value = new PropertyValue();
            value.Property = prop;
            value.Value = resource.LockDiscovery;
            result.Add(value);

            prop = new Property();
            prop.Name = "resourcetype";
            prop.PropertyType = typeof(int);
            value = new PropertyValue();
            value.Property = prop;
            value.Value = resource.ResourceType;
            result.Add(value);

            prop = new Property();
            prop.Name = "supportedlock";
            prop.PropertyType = typeof(int);
            value = new PropertyValue();
            value.Property = prop;
            value.Value = resource.SupportedLock;
            result.Add(value);

            prop = new Property();
            prop.Name = "lastmodified";
            prop.PropertyType = typeof(DateTime);
            value = new PropertyValue();
            value.Property = prop;
            value.Value = resource.UpdateDate;
            result.Add(value);

            return result;
        }
 public void AddRange(PropertyValueCollection value)
 {
 }