Esempio n. 1
0
        internal static void ToDirectoryFromSPCTNameToDN(string extendedAttribute, string[] directoryAttributes, ADPropertyValueCollection extendedData, ADEntity directoryObj, CmdletSessionInfo cmdletSessionInfo)
        {
            string str = ADPathModule.MakePath(cmdletSessionInfo.ADRootDSE.ConfigurationNamingContext, "CN=Claims Configuration,CN=Services,", ADPathFormat.X500);

            str = ADPathModule.MakePath(str, "CN=Claim Types,", ADPathFormat.X500);
            try
            {
                AttributeConverters.ToDirectoryFromADEntityToAttributeValue <ADClaimTypeFactory <ADClaimType>, ADClaimType>(str, null, extendedAttribute, directoryAttributes, extendedData, directoryObj, cmdletSessionInfo);
            }
            catch (ADIdentityResolutionException aDIdentityResolutionException1)
            {
                ADIdentityResolutionException aDIdentityResolutionException = aDIdentityResolutionException1;
                object[] message = new object[1];
                message[0] = aDIdentityResolutionException.Message;
                throw new ADIdentityResolutionException(string.Format(CultureInfo.CurrentCulture, StringResources.SharesValueWithIdentityError, message), aDIdentityResolutionException);
            }
        }
Esempio n. 2
0
        internal static IADOPathNode ToSearchFromADEntityToAttributeValue <F, O>(string searchBase, string attributeName, string extendedAttributeName, string[] directoryAttributes, IADOPathNode filterClause, CmdletSessionInfo cmdletSessionInfo)
            where F : ADFactory <O>, new()
            where O : ADEntity, new()
        {
            ADEntity          extendedObjectFromIdentity;
            IADOPathNode      binaryADOPathNode;
            BinaryADOPathNode binaryADOPathNode1 = filterClause as BinaryADOPathNode;

            if (binaryADOPathNode1 == null)
            {
                throw new ArgumentException(StringResources.SearchConverterNotBinaryNode);
            }
            else
            {
                if (binaryADOPathNode1.Operator == ADOperator.Eq || binaryADOPathNode1.Operator == ADOperator.Ne)
                {
                    IDataNode rightNode = binaryADOPathNode1.RightNode as IDataNode;
                    if (rightNode == null)
                    {
                        throw new ArgumentException(StringResources.SearchConverterRHSNotDataNode);
                    }
                    else
                    {
                        PropertyADOPathNode propertyADOPathNode = new PropertyADOPathNode(directoryAttributes[0]);
                        ObjectADOPathNode   objectADOPathNode   = new ObjectADOPathNode(null);
                        O dataObject = (O)(rightNode.DataObject as O);
                        if (dataObject == null)
                        {
                            string str = rightNode.DataObject as string;
                            if (str != null)
                            {
                                dataObject          = Activator.CreateInstance <O>();
                                dataObject.Identity = str;
                            }
                        }
                        if (dataObject == null)
                        {
                            object[] objArray = new object[2];
                            objArray[0] = rightNode.DataObject.ToString();
                            objArray[1] = extendedAttributeName;
                            throw new ArgumentException(string.Format(CultureInfo.CurrentCulture, StringResources.SearchConverterInvalidValue, objArray));
                        }
                        else
                        {
                            F f = Activator.CreateInstance <F>();
                            f.SetCmdletSessionInfo(cmdletSessionInfo);
                            try
                            {
                                if (attributeName != null)
                                {
                                    HashSet <string> strs = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
                                    strs.Add(attributeName);
                                    extendedObjectFromIdentity   = f.GetExtendedObjectFromIdentity(dataObject, searchBase, strs, false);
                                    objectADOPathNode.DataObject = (string)extendedObjectFromIdentity[attributeName].Value;
                                }
                                else
                                {
                                    extendedObjectFromIdentity   = f.GetDirectoryObjectFromIdentity(dataObject, searchBase);
                                    objectADOPathNode.DataObject = (string)extendedObjectFromIdentity["DistinguishedName"].Value;
                                }
                                binaryADOPathNode = new BinaryADOPathNode(binaryADOPathNode1.Operator, propertyADOPathNode, objectADOPathNode);
                            }
                            catch (ADIdentityNotFoundException aDIdentityNotFoundException1)
                            {
                                ADIdentityNotFoundException aDIdentityNotFoundException = aDIdentityNotFoundException1;
                                object[] message = new object[2];
                                message[0] = extendedAttributeName;
                                message[1] = aDIdentityNotFoundException.Message;
                                throw new ADIdentityResolutionException(string.Format(CultureInfo.CurrentCulture, StringResources.IdentityInExtendedAttributeCannotBeResolved, message), aDIdentityNotFoundException);
                            }
                            catch (ADIdentityResolutionException aDIdentityResolutionException1)
                            {
                                ADIdentityResolutionException aDIdentityResolutionException = aDIdentityResolutionException1;
                                object[] message1 = new object[2];
                                message1[0] = extendedAttributeName;
                                message1[1] = aDIdentityResolutionException.Message;
                                throw new ADIdentityResolutionException(string.Format(CultureInfo.CurrentCulture, StringResources.IdentityInExtendedAttributeCannotBeResolved, message1), aDIdentityResolutionException);
                            }
                            return(binaryADOPathNode);
                        }
                    }
                }
                else
                {
                    object[]     str1            = new object[2];
                    ADOperator[] aDOperatorArray = new ADOperator[2];
                    aDOperatorArray[1] = ADOperator.Ne;
                    str1[0]            = SearchConverters.ConvertOperatorListToString(aDOperatorArray);
                    str1[1]            = extendedAttributeName;
                    throw new NotSupportedException(string.Format(CultureInfo.CurrentCulture, StringResources.SearchConverterSupportedOperatorListErrorMessage, str1));
                }
            }
        }