Exemple #1
0
        /// <summary>
        /// Helper method: Sets attribute value in the attribute collection
        /// </summary>
        /// <param name="attName">attribute name</param>
        /// <param name="attValue">attribute value (if null, we will remove the attribute from the collection)</param>
        /// <param name="attributes">collection of attribute</param>
        /// <exception cref="ArgumentNullException">If some of the params is null</exception>
        internal static void SetAttValue(string attName, object attValue, ICollection <ConnectorAttribute> attributes)
        {
            Assertions.NullCheck(attName, "attName");
            Assertions.NullCheck(attributes, "attributes");

            ConnectorAttribute attribute = ConnectorAttributeUtil.Find(attName, attributes);

            if (attribute != null)
            {
                attributes.Remove(attribute);
            }
            if (attValue != null)
            {
                attributes.Add(ConnectorAttributeBuilder.Build(attName, new object[] { attValue }));
            }
        }
        public void MergeDeleteToExistingAttributeCompletely()
        {
            UpdateImpl up = new UpdateImpl(null, null);
            ICollection <ConnectorAttribute> actual;
            ICollection <ConnectorAttribute> baseAttrs = CollectionUtil.NewSet <ConnectorAttribute>();
            ICollection <ConnectorAttribute> expected  = CollectionUtil.NewSet <ConnectorAttribute>();
            ICollection <ConnectorAttribute> changeset = CollectionUtil.NewSet <ConnectorAttribute>();
            // attempt to add a value to an attribute..
            ConnectorAttribute battr = ConnectorAttributeBuilder.Build("abc", 1, 2);
            ConnectorAttribute cattr = ConnectorAttributeBuilder.Build("abc", 1, 2);

            baseAttrs.Add(battr);
            changeset.Add(cattr);
            expected.Add(ConnectorAttributeBuilder.Build("abc"));
            actual = up.Merge(changeset, baseAttrs, false);
            Assert.IsTrue(AreEqual(expected, actual));
        }
        /// <summary>
        /// Attribute normalizer
        /// </summary>
        /// <param name="oclass">Object class</param>
        /// <param name="attribute">Attribute to be normalized</param>
        /// <returns>Normalized attribute</returns>
        public ConnectorAttribute NormalizeAttribute(ObjectClass oclass, ConnectorAttribute attribute)
        {
            // normalize the attribute using AD connector first
            // attribute = base.NormalizeAttribute(oclass, attribute);

            // normalize mail-related attributes
            if (attribute.Is(ExchangeConnectorAttributes.AttExternalEmailAddress) || attribute.Is(ExchangeConnectorAttributes.AttForwardingSmtpAddress))
            {
                return(NormalizeSmtpAddressAttribute(attribute));
            }
            else
            {
                return(attribute);
            }

            // TODO: what with EmailAddresses? (we should not remove SMTP/smpt prefix, because it carries information on primary/secondary address type)
            // TODO: and other attributes?
        }
Exemple #4
0
        public void TestGetSingleValue()
        {
            object             TEST_VALUE = 1L;
            ConnectorAttribute attr       = ConnectorAttributeBuilder.Build("long", TEST_VALUE);
            object             value      = ConnectorAttributeUtil.GetSingleValue(attr);

            Assert.AreEqual(TEST_VALUE, value);

            // test null
            attr  = ConnectorAttributeBuilder.Build("long");
            value = ConnectorAttributeUtil.GetSingleValue(attr);
            Assert.IsNull(value);
            // test empty
            attr  = ConnectorAttributeBuilder.Build("long", new List <object>());
            value = ConnectorAttributeUtil.GetSingleValue(attr);
            Assert.IsNull(value);
            // test illegal argument exception
            ConnectorAttributeUtil.GetSingleValue(ConnectorAttributeBuilder.Build("bob", 1, 2, 3));
        }
            private IList <object> ValuesSorted(ConnectorObject resource, string field)
            {
                ConnectorAttribute value = resource.GetAttributeByName(field);

                if (value == null || value.Value == null || value.Value.Count == 0)
                {
                    return(new List <object>());
                }
                else if (value.Value.Count > 1)
                {
                    List <object> results = new List <object>(value.Value);
                    results.Sort(VALUE_COMPARATOR);
                    return(results);
                }
                else
                {
                    return(value.Value);
                }
            }
Exemple #6
0
        /// <summary>
        /// Helper method: Gets attribute value from the attribute collection
        /// </summary>
        /// <param name="attName">attribute name</param>
        /// <param name="attributes">collection of attribute</param>
        /// <returns>Attribute value as object, null if not found</returns>
        /// <exception cref="ArgumentNullException">If some of the params is null</exception>
        internal static object GetAttValue(string attName, ICollection <ConnectorAttribute> attributes)
        {
            Assertions.NullCheck(attName, "attName");

            if (attributes == null)
            {
                return(null);
            }

            object             value     = null;
            ConnectorAttribute attribute = ConnectorAttributeUtil.Find(attName, attributes);

            if (attribute != null)
            {
                value = ConnectorAttributeUtil.GetSingleValue(attribute) ?? string.Empty;
            }

            return(value);
        }
            /// <summary>
            /// Translates the connector attribute name to LDAP name
            /// </summary>
            /// <param name="attr">Connector attribute name</param>
            /// <returns>Translated string array</returns>
            protected override string[] GetLdapNamesForAttribute(ConnectorAttribute attr)
            {
                if (attr.Is(AttDatabase))
                {
                    return(new[] { AttDatabaseADName });
                }

                if (attr.Is(AttExternalMail))
                {
                    return(new[] { AttExternalMailADName });
                }

                if (attr.Is(AttRecipientType))
                {
                    return(null);
                }

                return(base.GetLdapNamesForAttribute(attr));
            }
Exemple #8
0
        /// <summary>
        /// Helper method: Gets attribute values from the attribute collection
        /// </summary>
        /// <param name="attName">attribute name</param>
        /// <param name="attributes">collection of attribute</param>
        /// <returns>Attribute value as collection of objects, null if not found</returns>
        /// <exception cref="ArgumentNullException">If some of the params is null</exception>
        internal static IList <object> GetAttValues(string attName, ICollection <ConnectorAttribute> attributes)
        {
            Assertions.NullCheck(attName, "attName");

            if (attributes == null)
            {
                return(null);
            }

            ConnectorAttribute attribute = ConnectorAttributeUtil.Find(attName, attributes);

            if (attribute != null)
            {
                return(attribute.Value);
            }
            else
            {
                return(null);
            }
        }
        private ConnectorAttribute NormalizeSmtpAddressAttribute(ConnectorAttribute attribute)
        {
            if (attribute.Value == null)
            {
                return(attribute);
            }

            IList <object> normValues = new List <object>();
            bool           normalized = false;

            foreach (object val in attribute.Value)
            {
                string strVal = val as string;
                if (strVal != null)
                {
                    string[] split = strVal.Split(':');
                    if (split.Length == 2)
                    {
                        // it contains delimiter, use the second part
                        normValues.Add(split[1]);
                        normalized = true;
                    }
                    else
                    {
                        // put the original value
                        normValues.Add(val);
                    }
                }
            }

            if (normalized)
            {
                // build the attribute again
                return(ConnectorAttributeBuilder.Build(attribute.Name, normValues));
            }
            else
            {
                return(attribute);
            }
        }
        /// <summary>
        /// Attribute normalizer
        /// </summary>
        /// <param name="oclass">Object class</param>
        /// <param name="attribute">Attribute to be normalized</param>
        /// <returns>Normalized attribute</returns>
        public override ConnectorAttribute NormalizeAttribute(ObjectClass oclass, ConnectorAttribute attribute)
        {
            // normalize the attribute using AD connector first
            attribute = base.NormalizeAttribute(oclass, attribute);

            // normalize external mail value
            if (attribute.Name == AttExternalMail && attribute.Value != null)
            {
                IList <object> normAttributes = new List <object>();
                bool           normalized     = false;
                foreach (object val in attribute.Value)
                {
                    string strVal = val as string;
                    if (strVal != null)
                    {
                        string[] split = strVal.Split(':');
                        if (split.Length == 2)
                        {
                            // it contains delimiter, use the second part
                            normAttributes.Add(split[1]);
                            normalized = true;
                        }
                        else
                        {
                            // put the original value
                            normAttributes.Add(val);
                        }
                    }
                }

                if (normalized)
                {
                    // build the attribute again
                    return(ConnectorAttributeBuilder.Build(attribute.Name, normAttributes));
                }
            }

            // return the original attribute
            return(attribute);
        }
Exemple #11
0
        /// <summary>
        /// Renames the connector attribute to new name; transforms value by keeping Common Name only
        /// </summary>
        /// <param name="cattribute">ConnectorAttribute to be renamed</param>
        /// <param name="newName">New attribute name</param>
        /// <returns>Renamed and transformed ConnectorAttribute</returns>
        /// <exception cref="ArgumentNullException">If some of the params is null</exception>
        internal static ConnectorAttribute ExtractCommonName(ConnectorAttribute cattribute, string newName)
        {
            Assertions.NullCheck(cattribute, "cattribute");
            Assertions.NullCheck(newName, "newName");

            var attBuilder = new ConnectorAttributeBuilder();

            if (cattribute.Value != null)
            {
                ICollection <object> convertedValues = new List <object>();
                foreach (object oldValue in cattribute.Value)
                {
                    if (oldValue != null)       // should be always the case
                    {
                        convertedValues.Add(ExtractCommonName(oldValue.ToString()));
                    }
                }
                attBuilder.AddValue(convertedValues);
            }
            attBuilder.Name = newName;
            return(attBuilder.Build());
        }
        /**
         * Get the LDAP name or names for a given connector attribute used in a
         * search filter.
         *
         * @param attr The connector attribute used in a search filter.
         *
         * @return The name or names of the corresponding LDAP attribute.
         *         Returns null if the attribute cannot be specified in an LDAP
         *         filter.
         */

        protected virtual String[] GetLdapNamesForAttribute(ConnectorAttribute attr)
        {
            // Special processing for certain connector attributes.
            String[] attrNames = null;
            if (attr is Uid)
            {
                /*
                 * attrNames = new String[] {
                 *   configCache.getConfiguration().getUuidAttribute() };
                 */
                attrNames = new String[] { "objectGUID" };
            }
            else if (attr is Name)
            {
                /*
                 * attrNames = configCache.getNamingAttributes();
                 */
                attrNames = new String [] { "distinguishedName" };
            }
            else if (attr.Is(OperationalAttributes.PASSWORD_NAME))
            {
                /*
                 * attrNames = new String[] {
                 *   configCache.getConfiguration().getPasswordAttribute()
                 * };
                 */
                attrNames = new String[] { "userPassword" };
            }
            else if (ConnectorAttributeUtil.IsSpecial(attr))
            {
                return(null);
            }
            else
            {
                attrNames = new String[] { attr.Name };
            }

            return(attrNames);
        }
Exemple #13
0
        private String CreateContainsAllValuesExpressionInternal(AttributeFilter filter, Boolean not)
        {
            if (not)
            {
                return(null);
            }

            ConnectorAttribute attr = filter.GetAttribute();

            if (attr is Uid)
            {
                return(((Uid)attr).GetUidValue());
            }
            else if (attr is Name)
            {
                return(((Name)attr).GetNameValue());
            }
            else
            {
                return(null);
            }
        }
Exemple #14
0
        public Uid Create(ObjectClass objClass, ICollection <ConnectorAttribute> attrs, OperationOptions options)
        {
            StringBuilder      sb            = new StringBuilder();
            ConnectorAttribute NameAttribute = ConnectorAttributeUtil.Find(Name.NAME, attrs);

            if (NameAttribute == null)
            {
                throw new ConnectorException("The name operational attribute cannot be null");
            }

            string parameter = ConnectorAttributeUtil.GetAsStringValue(NameAttribute);

            string[] login = parameter.Split('@');

            PowerShell PowerShellInstance = PowerShell.Create();

            PowerShellInstance.AddCommand(this.config.createScript + "create.ps1");
            PowerShellInstance.AddArgument(login[0]);

            Collection <PSObject>    results;
            Collection <ErrorRecord> errors;

            results = PowerShellInstance.Invoke();
            errors  = PowerShellInstance.Streams.Error.ReadAll();

            if (errors.Count > 0)
            {
                foreach (ErrorRecord error in errors)
                {
                    sb.AppendLine(error.ToString());
                }

                throw new ConnectorException(sb.ToString());
            }
            else
            {
                return(new Uid(ConnectorAttributeUtil.GetAsStringValue(NameAttribute)));
            }
        }
            /// <summary>
            /// Translates the connector attribute name to LDAP name
            /// </summary>
            /// <param name="attr">Connector attribute name</param>
            /// <returns>Translated string array</returns>
            protected override string[] GetLdapNamesForAttribute(ConnectorAttribute attr)
            {
                // Exchange attributes with known mappings to AD
                foreach (string attrNameInExchange in ExchangeConnectorAttributes.AttMap2AD.Keys)
                {
                    if (attr.Is(attrNameInExchange))
                    {
                        return(new[] { ExchangeConnectorAttributes.AttMap2AD[attrNameInExchange] });
                    }
                }

                // Other Exchange attributes have no mapping to AD ones.
                // This means that some attributes with more complicated mappings,
                // like RecipientType or EmailAddressPolicyEnabled, cannot be
                // used in search queries.
                if (ExchangeConnectorAttributes.IsExchangeAttribute(attr))
                {
                    return(null);
                }
                else
                {
                    return(base.GetLdapNamesForAttribute(attr));
                }
            }
Exemple #16
0
        /// <summary>
        /// Updates an AD object (also called by create after object is created)
        /// </summary>
        /// <param name="oclass"></param>
        /// <param name="directoryEntry"></param>
        /// <param name="attributes"></param>
        /// <param name="type"></param>
        /// <param name="config"></param>
        internal void UpdateADObject(ObjectClass oclass,
                                     DirectoryEntry directoryEntry, ICollection <ConnectorAttribute> attributes,
                                     UpdateType type, ActiveDirectoryConfiguration config)
        {
            if (oclass.Equals(ObjectClass.ACCOUNT))
            {
                // translate attribute passed in
                foreach (ConnectorAttribute attribute in attributes)
                {
                    // encountered problems when processing change password at the same time
                    // as setting expired.  It would be set to expired, but the change would
                    // clear that.  So we must ensure that expired comes last.
                    if (OperationalAttributes.PASSWORD_EXPIRED_NAME.Equals(attribute.Name))
                    {
                        continue;
                    }

                    AddConnectorAttributeToADProperties(oclass,
                                                        directoryEntry, attribute, type);

                    //  Uncommenting the next line is very helpful in
                    //  finding mysterious errors.
                    // Trace.TraceInformation("Committing after setting attribute {0} to {1}", attribute.Name, attribute.Value);
                    // directoryEntry.CommitChanges();
                }

                directoryEntry.CommitChanges();

                // now do the password change.  This is handled separately, because
                // it might be a user changing his own password, or it might be an
                // administrative change.

                GuardedString gsNewPassword = ConnectorAttributeUtil.GetPasswordValue(attributes);
                if (gsNewPassword != null)
                {
                    GuardedString         gsCurrentPassword = ConnectorAttributeUtil.GetCurrentPasswordValue(attributes);
                    PasswordChangeHandler changeHandler     = new PasswordChangeHandler(_configuration);
                    if (gsCurrentPassword == null)
                    {
                        // just a normal password change
                        changeHandler.changePassword(directoryEntry, gsNewPassword);
                    }
                    else
                    {
                        changeHandler.changePassword(directoryEntry,
                                                     gsCurrentPassword, gsNewPassword);
                    }


                    UserAccountControl.Set(directoryEntry.Properties[ActiveDirectoryConnector.ATT_USER_ACOUNT_CONTROL],
                                           UserAccountControl.PASSWD_NOTREQD, false);
                    directoryEntry.CommitChanges();
                }

                // see note in loop above for explaination of this
                ConnectorAttribute expirePasswordAttribute = ConnectorAttributeUtil.Find(
                    OperationalAttributes.PASSWORD_EXPIRED_NAME, attributes);

                if (expirePasswordAttribute != null)
                {
                    AddConnectorAttributeToADProperties(oclass,
                                                        directoryEntry, expirePasswordAttribute, type);
                    directoryEntry.CommitChanges();
                }

                /*
                 * UserAccountControl.Set(directoryEntry.Properties[ActiveDirectoryConnector.ATT_USER_ACOUNT_CONTROL],
                 *  UserAccountControl.PASSWD_NOTREQD, false);
                 */
                directoryEntry.CommitChanges();

                HandleNameAndContainerChange(type, directoryEntry, attributes, config);
            }
            else if (oclass.Equals(ActiveDirectoryConnector.groupObjectClass))
            {
                // translate attribute passed in
                foreach (ConnectorAttribute attribute in attributes)
                {
                    // Temporary
                    // Trace.TraceInformation(String.Format("Setting attribute {0} to {1}",
                    //    attribute.Name, attribute.Value));
                    AddConnectorAttributeToADProperties(oclass,
                                                        directoryEntry, attribute, type);
                    //                  Uncommenting the next line is very helpful in
                    //                  finding mysterious errors.
                    //                 directoryEntry.CommitChanges();
                }

                directoryEntry.CommitChanges();
                HandleNameAndContainerChange(type, directoryEntry, attributes, config);
            }
            else if (oclass.Equals(ActiveDirectoryConnector.ouObjectClass))
            {
                // translate attribute passed in
                foreach (ConnectorAttribute attribute in attributes)
                {
                    // Temporary
                    // Trace.TraceInformation(String.Format("Setting attribute {0} to {1}",
                    //    attribute.Name, attribute.Value));
                    AddConnectorAttributeToADProperties(oclass,
                                                        directoryEntry, attribute, type);
                    //                  Uncommenting the next line is very helpful in
                    //                  finding mysterious errors.
                    // directoryEntry.CommitChanges();
                }

                directoryEntry.CommitChanges();
                HandleNameAndContainerChange(type, directoryEntry, attributes, config);
            }
            else
            {
                String objectClassName = GetADObjectClass(oclass);
                // translate attribute passed in
                foreach (ConnectorAttribute attribute in attributes)
                {
                    // Temporary
                    // Trace.TraceInformation(String.Format("Setting attribute {0} to {1}",
                    //    attribute.Name, attribute.Value));
                    AddConnectorAttributeToADProperties(oclass,
                                                        directoryEntry, attribute, type);
                    //                  Uncommenting the next line is very helpful in
                    //                  finding mysterious errors.
                    // directoryEntry.CommitChanges();
                }

                directoryEntry.CommitChanges();
                HandleNameAndContainerChange(type, directoryEntry, attributes, config);
            }
        }
        /// <summary>
        /// Gets Recipient Type/Database from Exchange database, this method can be more general, but it is ok
        /// for out needs
        /// </summary>
        /// <param name="oc">object class, currently the moethod works for <see cref="ObjectClass.ACCOUNT"/> only</param>
        /// <param name="cobject">connector object to get the recipient type/database for</param>
        /// <param name="attToGet">attributes to get</param>
        /// <returns>Connector Object with recipient type added</returns>
        /// <exception cref="ConnectorException">In case of some troubles in powershell (if the
        /// user is not found we get this exception too)</exception>
        private ConnectorObject AddExchangeAttributes(ObjectClass oc, ConnectorObject cobject, IEnumerable <string> attToGet)
        {
            ExchangeUtility.NullCheck(oc, "name", this.configuration);
            ExchangeUtility.NullCheck(oc, "cobject", this.configuration);

            // we support ACCOUNT only or there is nothing to add
            if (!oc.Is(ObjectClass.ACCOUNT_NAME) || attToGet == null)
            {
                return(cobject);
            }

            // check it is not deleted object
            bool?deleted = ExchangeUtility.GetAttValue(AttIsDeleted, cobject.GetAttributes()) as bool?;

            if (deleted != null && deleted == true)
            {
                // do nothing, it is deleted object
                return(cobject);
            }

            ICollection <string> lattToGet = CollectionUtil.NewCaseInsensitiveSet();

            CollectionUtil.AddAll(lattToGet, attToGet);
            foreach (string att in attToGet)
            {
                if (cobject.GetAttributeByName(att) != null && att != AttDatabase)
                {
                    lattToGet.Remove(att);
                }
            }

            if (lattToGet.Count == 0)
            {
                return(cobject);
            }

            ConnectorObjectBuilder cobjBuilder = new ConnectorObjectBuilder();

            cobjBuilder.AddAttributes(cobject.GetAttributes());

            PSExchangeConnector.CommandInfo cmdInfo = PSExchangeConnector.CommandInfo.GetUser;

            // prepare the connector attribute list to get the command
            ICollection <ConnectorAttribute> attributes = new Collection <ConnectorAttribute> {
                cobject.Name
            };

            // get the command
            Command cmd = ExchangeUtility.GetCommand(cmdInfo, attributes, this.configuration);
            ICollection <PSObject> foundObjects = this.InvokePipeline(cmd);
            PSObject user = null;

            if (foundObjects != null && foundObjects.Count == 1)
            {
                user = GetFirstElement(foundObjects);
                foreach (var info in user.Properties)
                {
                    ConnectorAttribute att = GetAsAttribute(info);
                    if (att != null && lattToGet.Contains(att.Name))
                    {
                        cobjBuilder.AddAttribute(att);
                        lattToGet.Remove(att.Name);
                    }
                }

                if (lattToGet.Count == 0)
                {
                    return(cobjBuilder.Build());
                }
            }

            if (user == null)
            {
                // nothing to do
                return(cobject);
            }

            string rcptType = user.Members[AttRecipientType].Value.ToString();

            foundObjects = null;

            // get detailed information
            if (rcptType == RcptTypeMailBox)
            {
                foundObjects = this.InvokePipeline(ExchangeUtility.GetCommand(PSExchangeConnector.CommandInfo.GetMailbox, attributes, this.configuration));
            }
            else if (rcptType == RcptTypeMailUser)
            {
                foundObjects = this.InvokePipeline(ExchangeUtility.GetCommand(PSExchangeConnector.CommandInfo.GetMailUser, attributes, this.configuration));
            }

            if (foundObjects != null && foundObjects.Count == 1)
            {
                PSObject userDetails = GetFirstElement(foundObjects);
                foreach (var info in userDetails.Properties)
                {
                    ConnectorAttribute att = GetAsAttribute(info);
                    if (att != null && lattToGet.Contains(att.Name))
                    {
                        cobjBuilder.AddAttribute(att);
                        lattToGet.Remove(att.Name);
                    }
                }
            }

            return(cobjBuilder.Build());
        }
Exemple #18
0
        public void TestBasics()
        {
            ConnectorAttribute attribute =
                ConnectorAttributeBuilder.Build("att-name", "att-value");
            ConnectorAttribute attribute2 =
                ConnectorAttributeBuilder.Build("att-name2", "att-value2");
            AllFiltersTranslator translator = new
                                              AllFiltersTranslator();

            {
                Filter filter =
                    FilterBuilder.Contains(attribute);
                String expected = "( CONTAINS att-name att-value )";
                String actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);

                filter   = FilterBuilder.Not(filter);
                expected = "( ! " + expected + " )";
                actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);
            }

            {
                Filter filter =
                    FilterBuilder.EndsWith(attribute);
                String expected = "( ENDS-WITH att-name att-value )";
                String actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);

                filter   = FilterBuilder.Not(filter);
                expected = "( ! " + expected + " )";
                actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);
            }

            {
                Filter filter =
                    FilterBuilder.EqualTo(attribute);
                String expected = "( = att-name [att-value] )";
                String actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);

                filter   = FilterBuilder.Not(filter);
                expected = "( ! " + expected + " )";
                actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);
            }

            {
                Filter filter =
                    FilterBuilder.GreaterThan(attribute);
                String expected = "( > att-name att-value )";
                String actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);

                filter   = FilterBuilder.Not(filter);
                expected = "( ! " + expected + " )";
                actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);
            }

            {
                Filter filter =
                    FilterBuilder.GreaterThanOrEqualTo(attribute);
                String expected = "( >= att-name att-value )";
                String actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);

                filter   = FilterBuilder.Not(filter);
                expected = "( ! " + expected + " )";
                actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);
            }

            {
                Filter filter =
                    FilterBuilder.LessThan(attribute);
                String expected = "( < att-name att-value )";
                String actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);

                filter   = FilterBuilder.Not(filter);
                expected = "( ! " + expected + " )";
                actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);
            }

            {
                Filter filter =
                    FilterBuilder.LessThanOrEqualTo(attribute);
                String expected = "( <= att-name att-value )";
                String actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);

                filter   = FilterBuilder.Not(filter);
                expected = "( ! " + expected + " )";
                actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);
            }

            {
                Filter filter =
                    FilterBuilder.StartsWith(attribute);
                String expected = "( STARTS-WITH att-name att-value )";
                String actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);

                filter   = FilterBuilder.Not(filter);
                expected = "( ! " + expected + " )";
                actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);
            }

            {
                Filter filter =
                    FilterBuilder.ContainsAllValues(attribute);
                String expected = "( CONTAINS-ALL-VALUES " + attribute + " )";
                String actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);

                filter   = FilterBuilder.Not(filter);
                expected = "( ! " + expected + " )";
                actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);
            }

            //and
            {
                Filter left =
                    FilterBuilder.Contains(attribute);
                Filter right =
                    FilterBuilder.Contains(attribute2);
                String expectedLeft  = "( CONTAINS att-name att-value )";
                String expectedRight = "( CONTAINS att-name2 att-value2 )";
                Filter filter        =
                    FilterBuilder.And(left, right);
                String expected =
                    "( & " + expectedLeft + " " + expectedRight + " )";
                String actual =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);

                filter        = FilterBuilder.Not(filter);
                expectedLeft  = "( ! " + expectedLeft + " )";
                expectedRight = "( ! " + expectedRight + " )";
                expected      =
                    "( | " + expectedLeft + " " + expectedRight + " )";
                actual =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);
            }

            //or
            {
                Filter left =
                    FilterBuilder.Contains(attribute);
                Filter right =
                    FilterBuilder.Contains(attribute2);
                String expectedLeft  = "( CONTAINS att-name att-value )";
                String expectedRight = "( CONTAINS att-name2 att-value2 )";
                Filter filter        =
                    FilterBuilder.Or(left, right);
                String expected =
                    "( | " + expectedLeft + " " + expectedRight + " )";
                String actual =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);

                filter        = FilterBuilder.Not(filter);
                expectedLeft  = "( ! " + expectedLeft + " )";
                expectedRight = "( ! " + expectedRight + " )";
                expected      =
                    "( & " + expectedLeft + " " + expectedRight + " )";
                actual =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);
            }

            //double-negative
            {
                Filter filter =
                    FilterBuilder.Contains(attribute);
                filter = FilterBuilder.Not(filter);
                filter = FilterBuilder.Not(filter);
                String expected = "( CONTAINS att-name att-value )";
                String actual   =
                    TranslateSingle(translator, filter);
                Assert.AreEqual(expected, actual);
            }
        }
Exemple #19
0
 internal static bool IsExchangeAttribute(ConnectorAttribute attr)
 {
     return(IsExchangeAttribute(attr.Name));
 }
Exemple #20
0
        // creates a collection of attributes that correspond to the original ones, but resolves ADD/DELETE using existing values of psuser
        public ICollection <ConnectorAttribute> DetermineNewAttributeValues(UpdateOpContext context, ConnectorObject originalObject)
        {
            if (context.UpdateType == UpdateType.REPLACE)
            {
                // TODO check multivaluedness and updateability (as below)
                return(new List <ConnectorAttribute>(context.Attributes));
            }
            else
            {
                Boolean add;
                if (context.UpdateType == UpdateType.ADD)
                {
                    add = true;
                }
                else if (context.UpdateType == UpdateType.DELETE)
                {
                    add = false;
                }
                else
                {
                    throw new ArgumentException("Unsupported update type: " + context.UpdateType);
                }

                Schema schema = null;
                ICollection <ConnectorAttribute> rv = new List <ConnectorAttribute>(context.Attributes.Count);
                foreach (ConnectorAttribute attribute in context.Attributes)
                {
                    ConnectorAttribute originalAttribute = originalObject.GetAttributeByName(attribute.Name);
                    IList <object>     newValues         = originalAttribute != null && originalAttribute.Value != null ? new List <object>(originalAttribute.Value) : new List <object>();
                    Boolean            changed           = false;
                    if (attribute.Value != null)
                    {
                        foreach (object item in attribute.Value)
                        {
                            if (add)
                            {
                                if (newValues.Contains(item))
                                {
                                    LOG.Warn("Trying to add value from " + attribute.Name + " that is already there: " + item);
                                }
                                else
                                {
                                    newValues.Add(item);
                                    changed = true;
                                }
                            }
                            else
                            {
                                if (!newValues.Contains(item))
                                {
                                    LOG.Warn("Trying to remove value from " + attribute.Name + " that is not there: " + item);
                                }
                                else
                                {
                                    newValues.Remove(item);
                                    changed = true;
                                }
                            }
                        }
                    }
                    if (changed)
                    {
                        ConnectorAttributeBuilder b = new ConnectorAttributeBuilder();
                        b.Name = attribute.Name;
                        b.AddValue(newValues);
                        ConnectorAttribute modified = b.Build();

                        if (schema == null)
                        {
                            ExchangeConnector connector = (ExchangeConnector)context.Connector;
                            schema = connector.Schema();
                        }
                        ObjectClassInfo oci = schema.FindObjectClassInfo(context.ObjectClass.Type);
                        if (oci == null)
                        {
                            throw new InvalidOperationException("No object class info for " + context.ObjectClass.Type + " in the schema");
                        }
                        var cai = ConnectorAttributeInfoUtil.Find(attribute.Name, oci.ConnectorAttributeInfos);
                        if (cai == null)
                        {
                            throw new InvalidOperationException("No connector attribute info for " + context.ObjectClass.Type + " in the schema");
                        }

                        if (!cai.IsUpdateable)
                        {
                            throw new ConnectorSecurityException("Attempt to update a non-updateable attribute (" + attribute.Name + "): " +
                                                                 CollectionUtil.Dump(newValues));
                        }

                        if (newValues.Count > 1 && !cai.IsMultiValued)
                        {
                            throw new InvalidAttributeValueException("More than one value in a single-valued attribute (" + attribute.Name + "): " +
                                                                     CollectionUtil.Dump(newValues));
                        }
                        rv.Add(modified);
                    }
                }
                return(rv);
            }
        }
        protected override String CreateEqualsExpression(EqualsFilter filter, Boolean not)
        {
            // The LDAP equality filter matches any one attribute value,
            // whereas the connector EqualsFilter matches an attribute and
            // its values exactly.
            if (not)
            {
                return(null);
            }

            ConnectorAttribute attr = filter.GetAttribute();

            // if there is only one thing to search on, and it's
            // a uid we need to convert the uid to something we
            // can search on.  NOTE:  only handling the case where
            // we are doing an equality search, and only one item
            // is in the equality search ... It's all that makes
            // sense for uid.
            if (attr is Uid)
            {
                String attrValue = ((Uid)attr).GetUidValue();
                if (LooksLikeGUID(attrValue))
                {
                    String searchGuid = GetUidSearchString(((Uid)attr).GetUidValue());
                    attr = new Uid(searchGuid);
                }
                else
                {
                    attr = new Name(attrValue);
                }
            }


            String[] attrNames = GetLdapNamesForAttribute(attr);
            if (attrNames == null)
            {
                return(null);
            }

            StringBuilder builder = new StringBuilder();

            if (attr.Value == null)
            {
                return(null);
            }
            if (attr.Value.Count == 1)
            {
                BuildEqualityFilter(builder, attrNames,
                                    attr.Value[0]);
            }
            else
            {
                builder.Append("(&");
                foreach (Object value in attr.Value)
                {
                    BuildEqualityFilter(builder, attrNames, value);
                }
                builder.Append(')');
            }

            return(builder.ToString());
        }
        public void TestScripting()
        {
            ConnectorInfoManager manager =
                GetConnectorInfoManager();
            ConnectorInfo info =
                FindConnectorInfo(manager,
                                  "1.0.0.0",
                                  "org.identityconnectors.testconnector.TstConnector");

            Assert.IsNotNull(info);
            APIConfiguration api = info.CreateDefaultAPIConfiguration();


            ConnectorFacadeFactory facf   = ConnectorFacadeFactory.GetInstance();
            ConnectorFacade        facade = facf.NewInstance(api);

            ScriptContextBuilder builder = new ScriptContextBuilder();

            builder.AddScriptArgument("arg1", "value1");
            builder.AddScriptArgument("arg2", "value2");
            builder.ScriptLanguage = ("BOO");

            //test that they can run the script and access the
            //connector object
            {
                String SCRIPT =
                    "connector.concat(arg1,arg2)";
                builder.ScriptText = (SCRIPT);
                String result = (String)facade.RunScriptOnConnector(builder.Build(),
                                                                    null);

                Assert.AreEqual("value1value2", result);
            }

            //test that they can access a class in the class loader
            {
                String SCRIPT =
                    "import org.identityconnectors.testconnector\n" +
                    "TstConnector.GetVersion()";
                builder.ScriptText = (SCRIPT);
                String result = (String)facade.RunScriptOnConnector(builder.Build(),
                                                                    null);
                Assert.AreEqual("1.0", result);
            }

            //test that they cannot access a class in internal
            {
                Type clazz = typeof(ConfigurationPropertyImpl);

                String SCRIPT =
                    "import " + clazz.Namespace + "\n" +
                    clazz.Name + "()";
                builder.ScriptText = (SCRIPT);
                try
                {
                    facade.RunScriptOnConnector(builder.Build(),
                                                null);
                    Assert.Fail("exception expected");
                }
                catch (Exception e)
                {
                    String msg             = e.Message;
                    String expectedMessage =
                        "Namespace '" + clazz.Namespace + "' not found";
                    Assert.IsTrue(
                        msg.Contains(expectedMessage),
                        "Unexpected message: " + msg);
                }
            }

            // test that they can access a class in common
            {
                Type   clazz  = typeof(ConnectorAttributeBuilder);
                String SCRIPT =
                    "import " + clazz.Namespace + "\n" +
                    clazz.Name + ".Build(\"myattr\")";
                builder.ScriptText = (SCRIPT);
                ConnectorAttribute attr = (ConnectorAttribute)facade.RunScriptOnConnector(builder.Build(), null);
                Assert.AreEqual("myattr", attr.Name);
            }
        }
Exemple #23
0
        internal void AddConnectorAttributeToADProperties(ObjectClass oclass,
                                                          DirectoryEntry directoryEntry, ConnectorAttribute attribute,
                                                          UpdateType type)
        {
            // Boolean translated = false;
            if (directoryEntry == null)
            {
                throw new ConnectorException(_configuration.ConnectorMessages.Format(
                                                 "ex_CouldNotAddNullAttributeToDe",
                                                 "Could not add connector attribute to <null> directory entry"));
            }

            _customHandlers.UpdateDeFromCa(oclass, type,
                                           directoryEntry, attribute);
        }
        /// <summary>
        /// DeduplicatesEmailAddresses.
        ///  - on REPLACE (i.e. update/replace or create) the situation is easy: we just remove duplicate entries (SMTP:x & smtp:x result in SMTP:x)
        ///  - on DELETE we currently do nothing
        ///  - on ADD we have one additional rule:
        ///     "If we are adding SMTP:x, we first convert all SMTP:y in existing records to smtp:y because we see the intent of having x to be a new primary"
        ///
        /// </summary>
        /// <param name="context"></param>
        /// <param name="attributes">these are attributes to be set (already resolved if we have update of type ADD or DELETE)</param>
        /// <returns></returns>
        private ICollection <ConnectorAttribute> DeduplicateEmailAddresses(CreateUpdateOpContext context, ICollection <ConnectorAttribute> attributes)
        {
            // trivial cases

            if (context is UpdateOpContext && ((UpdateOpContext)context).UpdateType == UpdateType.DELETE)
            {
                return(attributes);
            }

            ConnectorAttribute attribute = ConnectorAttributeUtil.Find(ExchangeConnectorAttributes.AttEmailAddresses, attributes);

            if (attribute == null || attribute.Value == null)
            {
                return(attributes);      // missing or empty EmailAddresses - nothing to deduplicate
            }
            ConnectorAttribute attributeDelta = ConnectorAttributeUtil.Find(ExchangeConnectorAttributes.AttEmailAddresses, context.Attributes);

            if (attributeDelta == null || attributeDelta.Value == null)
            {
                return(attributes);      // missing or empty changed EmailAddresses - nothing to deduplicate
            }

            // now the main part

            IList <string> valuesToDeduplicate = new List <string>();

            foreach (object o in attribute.Value)
            {
                if (o != null)
                {
                    valuesToDeduplicate.Add(o.ToString());
                }
            }
            bool changed = false;

            // special rule: if ADD with SMTP:, let us change all other "SMTP:x" to "smtp:x"
            Boolean isUpdateAdd = context is UpdateOpContext && ((UpdateOpContext)context).UpdateType == UpdateType.ADD;

            if (isUpdateAdd)
            {
                string newPrimary = null;
                foreach (object o in attributeDelta.Value)
                {
                    if (((string)o).StartsWith("SMTP:"))
                    {
                        newPrimary = (string)o;
                        break;
                    }
                }
                if (newPrimary != null)
                {
                    foreach (string address in new List <string>(valuesToDeduplicate))      // to eliminate concurrent access
                    {
                        if (address.StartsWith("SMTP:") && !address.Equals(newPrimary))
                        {
                            string replacement = "smtp:" + address.Substring(5);
                            LOGGER.TraceEvent(TraceEventType.Information, CAT_DEFAULT, "Changing duplicate primary-candidate address {0} to {1}", address, replacement);
                            valuesToDeduplicate.Remove(address);
                            valuesToDeduplicate.Add(replacement);
                            changed = true;
                        }
                    }
                }
            }

            IDictionary <string, string> values = new Dictionary <string, string>();       // normalized->most-recent-original e.g. SMTP:[email protected] -> SMTP:[email protected] (if primary is present)

            foreach (object v in valuesToDeduplicate)
            {
                string address    = (string)v;
                string normalized = address.ToUpper();
                if (values.ContainsKey(normalized))
                {
                    changed = true;
                    string existing = values[normalized];
                    if (address.StartsWith("SMTP:") && existing.StartsWith("smtp:"))
                    {
                        LOGGER.TraceEvent(TraceEventType.Information, CAT_DEFAULT, "Removing redundant address {0}, keeping {1}", existing, address);
                        values[normalized] = address;
                    }
                    else
                    {
                        LOGGER.TraceEvent(TraceEventType.Information, CAT_DEFAULT, "Removing redundant address {0}, keeping {1}", address, existing);
                    }
                }
                else
                {
                    values.Add(normalized, address);
                }
            }
            if (changed)
            {
                ConnectorAttributeBuilder cab = new ConnectorAttributeBuilder();
                cab.Name = ExchangeConnectorAttributes.AttEmailAddresses;
                foreach (string value in values.Values)
                {
                    cab.AddValue(value);
                }
                ICollection <ConnectorAttribute> rv = new List <ConnectorAttribute>(attributes);          // the original is (sometimes) a read-only collection
                rv.Remove(attribute);
                rv.Add(cab.Build());
                return(rv);
            }
            else
            {
                return(attributes);
            }
        }
        private void AddOrReplaceDatabase(ObjectClass oclass, Uid uid, ICollection <ConnectorAttribute> attributes, OperationOptions options, AbstractConfiguration connectorConfiguration)
        {
            if (!ObjectClass.ACCOUNT.Equals(oclass))
            {
                LOG.Info("Nothing to do");
                return;
            }
            // вычисляем значение атрибута Database только если он не был передан
            // и дополнительно пришёл атрибут RecipientType со значением UserMailbox
            ConnectorAttribute database      = GetAttribute(attributes, "Database");
            ConnectorAttribute recipientType = GetAttribute(attributes, "RecipientType");

            if (database != null || recipientType == null || !recipientType.Value.First().ToString().Equals("UserMailbox"))
            {
                LOG.Info("Nothing to do");
                return;
            }

            DirectoryEntry container = null;

            try
            {
                ActiveDirectoryConfiguration config = (ActiveDirectoryConfiguration)connectorConfiguration;

                // вычисляем dn, для update'а находим по uid
                string dn = "";
                if (uid != null)
                {
                    DirectoryEntry entry = new DirectoryEntry(ActiveDirectoryUtils.GetLDAPPath(config.LDAPHostName, uid.GetUidValue()), config.DirectoryAdminName, config.DirectoryAdminPassword);
                    dn = (string)entry.Properties["distinguishedName"][0];
                    entry.Dispose();
                }
                else
                {
                    dn = GetAttribute(attributes, "__NAME__").Value.First().ToString();
                }
                string parentDn          = ActiveDirectoryUtils.GetParentDn(dn);
                string ldapContainerPath = ActiveDirectoryUtils.GetLDAPPath(config.LDAPHostName, parentDn);

                container = new DirectoryEntry(ldapContainerPath, config.DirectoryAdminName, config.DirectoryAdminPassword);

                // поиск значения Database в родительских OU
                string defaultHomeMdb = null;
                while (defaultHomeMdb == null && container != null)
                {
                    LOG.Info("Looking for DefaultHomeMdb in {0}", container.Path);
                    defaultHomeMdb = GetDefaultHomeMdb(container);
                    if (defaultHomeMdb != null)
                    {
                        LOG.Info("Found! DefaultHomeMdb = {0} (in container {1})", defaultHomeMdb, container.Path);
                    }
                    else
                    {
                        LOG.Info("Did not found DefaultHomeMdb in container {0}", container.Path);
                    }
                    try
                    {
                        container = container.Parent;
                    }
                    catch (Exception e)
                    {
                        LOG.Info("Error: " + e.Message);
                        container = null;
                    }
                }

                // установка значения атрибута, если не нашли указываем значение по умолчанию
                if (defaultHomeMdb != null)
                {
                    LOG.Info("Setting DefaultHomeMdb: " + defaultHomeMdb);
                    AddOrReplaceAttribute(attributes, "Database", defaultHomeMdb);
                }
                else
                {
                    LOG.Info("Did not found DefaultHomeMdb, will set default value");
                    AddOrReplaceAttribute(attributes, "Database", "MSK-RN-DAG01-1GB-02");
                }
            }
            finally
            {
                if (container != null)
                {
                    container.Dispose();
                }
            }
        }
Exemple #26
0
        /// <summary>
        /// Creates command based on the commanf info, reading the calues from attributes
        /// </summary>
        /// <param name="cmdInfo">Command defition</param>
        /// <param name="attributes">Attribute values - UID in these is ignored! It should be passed as a separate parameter</param>
        /// <param name="config">Configuration object</param>
        /// <returns>
        /// Ready to execute Command
        /// </returns>
        /// <exception cref="ArgumentNullException">if some of the param is null</exception>
        internal static Command GetCommand(PSExchangeConnector.CommandInfo cmdInfo, ICollection <ConnectorAttribute> attributes, Uid uidAttribute, Name nameAttribute, ExchangeConfiguration config)
        {
            Assertions.NullCheck(cmdInfo, "cmdInfo");

            LOG.Trace("GetCommand: cmdInfo name = {0}", cmdInfo.Name);

            ISet <string> parametersSet = new HashSet <string>();

            // create command
            Command cmd = new Command(cmdInfo.Name);

            if (!string.IsNullOrEmpty(cmdInfo.UidParameter) && !parametersSet.Contains(cmdInfo.UidParameter))
            {
                Uid    uidAttr = uidAttribute != null ? uidAttribute : ConnectorAttributeUtil.GetUidAttribute(attributes);
                string uid     = uidAttr != null?uidAttr.GetUidValue() : null;

                if (uid != null)
                {
                    cmd.Parameters.Add(cmdInfo.UidParameter, ActiveDirectoryUtils.ConvertADGUIDtoObjectGUID(uid));
                    parametersSet.Add(cmdInfo.UidParameter);
                }
            }

            // map name attribute, if mapping specified
            if (!string.IsNullOrEmpty(cmdInfo.NameParameter) && !parametersSet.Contains(cmdInfo.NameParameter))
            {
                Name   nameAttr = nameAttribute != null ? nameAttribute : ConnectorAttributeUtil.GetNameFromAttributes(attributes);
                string name     = nameAttr != null?nameAttr.GetNameValue() : null;;
                if (name != null)
                {
                    cmd.Parameters.Add(cmdInfo.NameParameter, name);
                    parametersSet.Add(cmdInfo.NameParameter);
                }
            }

            if (cmdInfo.UsesConfirm)
            {
                cmd.Parameters.Add("confirm", false);
                parametersSet.Add("confirm");
            }

            if (cmdInfo.UsesDomainController)
            {
                cmd.Parameters.Add("DomainController", ActiveDirectoryUtils.GetDomainControllerName(config));
                parametersSet.Add("DomainController");
            }

            // TODO check this only for user-related operations
            bool emailAddressesPresent     = GetAttValues(ExchangeConnectorAttributes.AttEmailAddresses, attributes) != null;
            bool primarySmtpAddressPresent = GetAttValues(ExchangeConnectorAttributes.AttPrimarySmtpAddress, attributes) != null;

            if (emailAddressesPresent && primarySmtpAddressPresent)
            {
                throw new ArgumentException(ExchangeConnectorAttributes.AttEmailAddresses + " and " + ExchangeConnectorAttributes.AttPrimarySmtpAddress + " cannot be both set.");
            }

            if (attributes != null)
            {
                foreach (string attName in cmdInfo.Parameters)
                {
                    object valueToSet = null;

                    ConnectorAttribute attribute = ConnectorAttributeUtil.Find(attName, attributes);
                    if (attribute != null)
                    {
                        if (attribute.Value != null && attribute.Value.Count > 1)
                        {
                            List <string> stringValues = new List <string>();
                            foreach (object val in attribute.Value)
                            {
                                stringValues.Add(val.ToString());
                            }
                            valueToSet = stringValues.ToArray();
                        }
                        else
                        {
                            valueToSet = ConnectorAttributeUtil.GetSingleValue(attribute);
                        }
                        if (parametersSet.Contains(attName))
                        {
                            throw new InvalidOperationException("Parameter " + attName + " is already defined for command " + cmdInfo.Name);
                        }
                        cmd.Parameters.Add(attName, valueToSet);
                        parametersSet.Add(attName);
                    }
                }
            }

            LOG.Trace("GetCommand exit: cmdInfo name = {0}", cmdInfo.Name);
            return(cmd);
        }
Exemple #27
0
        public Uid Update(ObjectClass objclass, Uid uid, ICollection <ConnectorAttribute> replaceAttributes, OperationOptions options)
        {
            StringBuilder sb = new StringBuilder();
            PowerShell    PowerShellInstance = PowerShell.Create();

            ConnectorAttribute StatusAttribute = ConnectorAttributeUtil.Find(OperationalAttributes.ENABLE_NAME, replaceAttributes);
            String             enable          = ConnectorAttributeUtil.GetAsStringValue(StatusAttribute).ToLower();

            string parameter = ConnectorAttributeUtil.GetAsStringValue(uid);

            string[] login = parameter.Split('@');

            if (enable.Equals("false"))
            {
                PowerShellInstance.AddCommand(this.config.createScript + "disable.ps1");
                PowerShellInstance.AddArgument(login[0]);

                Collection <PSObject>    results;
                Collection <ErrorRecord> errors;

                results = PowerShellInstance.Invoke();
                errors  = PowerShellInstance.Streams.Error.ReadAll();

                if (errors.Count > 0)
                {
                    foreach (ErrorRecord error in errors)
                    {
                        sb.AppendLine(error.ToString());
                    }

                    throw new ConnectorException(sb.ToString());
                }
                else
                {
                    return(uid);
                }
            }
            else if (enable.Equals("true"))
            {
                PowerShellInstance.AddCommand(this.config.createScript + "enable.ps1");
                PowerShellInstance.AddArgument(login[0]);

                Collection <PSObject>    results;
                Collection <ErrorRecord> errors;

                results = PowerShellInstance.Invoke();
                errors  = PowerShellInstance.Streams.Error.ReadAll();

                if (errors.Count > 0)
                {
                    foreach (ErrorRecord error in errors)
                    {
                        sb.AppendLine(error.ToString());
                    }

                    throw new ConnectorException(sb.ToString());
                }
                else
                {
                    return(uid);
                }
            }
            else
            {
                return(uid);
            }
        }
        public void Create(CreateOpContext context)
        {
            context.Attributes = DeduplicateEmailAddresses(context, context.Attributes);

            // get recipient type
            string rcptType = ExchangeUtility.GetAttValue(ExchangeConnectorAttributes.AttRecipientType, context.Attributes) as string;

            if (rcptType == null || rcptType.Equals(""))
            {
                rcptType = ExchangeConnectorAttributes.RcptTypeUser;
            }

            ExchangeConnector        exconn = (ExchangeConnector)context.Connector;
            ActiveDirectoryConnector adconn = exconn.ActiveDirectoryConnector;

            PSExchangeConnector.CommandInfo cmdInfoEnable = null;
            PSExchangeConnector.CommandInfo cmdInfoSet    = null;
            switch (rcptType)
            {
            case ExchangeConnectorAttributes.RcptTypeMailBox:
                cmdInfoEnable = PSExchangeConnector.CommandInfo.EnableMailbox;
                cmdInfoSet    = PSExchangeConnector.CommandInfo.SetMailbox;
                break;

            case ExchangeConnectorAttributes.RcptTypeMailUser:
                cmdInfoEnable = PSExchangeConnector.CommandInfo.EnableMailUser;
                cmdInfoSet    = PSExchangeConnector.CommandInfo.SetMailUser;
                break;

            case ExchangeConnectorAttributes.RcptTypeUser:
                break;

            default:
                throw new ArgumentException(
                          context.ConnectorConfiguration.ConnectorMessages.Format(
                              "ex_bad_rcpt", "Recipient type [{0}] is not supported", rcptType));
            }

            // first create the object in AD
            ICollection <ConnectorAttribute> adAttributes = ExchangeUtility.FilterOut(context.Attributes,
                                                                                      PSExchangeConnector.CommandInfo.EnableMailbox,
                                                                                      PSExchangeConnector.CommandInfo.SetMailbox,
                                                                                      PSExchangeConnector.CommandInfo.EnableMailUser,
                                                                                      PSExchangeConnector.CommandInfo.SetMailUser);
            Uid uid = adconn.Create(context.ObjectClass, adAttributes, context.Options);

            if (rcptType == ExchangeConnectorAttributes.RcptTypeUser)
            {
                // AD account only, we do nothing
                context.Uid = uid;
                return;
            }

            // add a empty "EmailAddresses" attribute if needed (address policy is disabled and no addresses are provided)
            ICollection <ConnectorAttribute> enhancedAttributes;
            ConnectorAttribute policyEnabledAttribute = ConnectorAttributeUtil.Find(ExchangeConnectorAttributes.AttEmailAddressPolicyEnabled, context.Attributes);

            if (policyEnabledAttribute != null &&
                ConnectorAttributeUtil.GetBooleanValue(policyEnabledAttribute).HasValue&&
                ConnectorAttributeUtil.GetBooleanValue(policyEnabledAttribute).Value == false &&
                ConnectorAttributeUtil.Find(ExchangeConnectorAttributes.AttPrimarySmtpAddress, context.Attributes) == null &&
                ConnectorAttributeUtil.Find(ExchangeConnectorAttributes.AttEmailAddresses, context.Attributes) == null)
            {
                enhancedAttributes = new HashSet <ConnectorAttribute>(context.Attributes);
                enhancedAttributes.Add(ConnectorAttributeBuilder.Build(ExchangeConnectorAttributes.AttEmailAddresses));
                LOGGER.TraceEvent(TraceEventType.Verbose, CAT_DEFAULT, "Added empty EmailAddresses attribute because address policy use is disabled and no addresses were provided");
            }
            else
            {
                enhancedAttributes = context.Attributes;        // no change
            }

            // prepare the command
            Command cmdEnable = ExchangeUtility.GetCommand(cmdInfoEnable, enhancedAttributes, uid, (ExchangeConfiguration)context.ConnectorConfiguration);
            Command cmdSet    = ExchangeUtility.GetCommand(cmdInfoSet, enhancedAttributes, uid, (ExchangeConfiguration)context.ConnectorConfiguration);

            try {
                _helper.InvokePipeline(exconn, cmdEnable);
                _helper.InvokePipeline(exconn, cmdSet);
            }
            catch {
                LOGGER.TraceEvent(TraceEventType.Information, CAT_DEFAULT, "Rolling back AD create for UID: " + uid.GetUidValue());

                // rollback AD create
                try {
                    adconn.Delete(context.ObjectClass, uid, context.Options);
                } catch {
                    LOGGER.TraceEvent(TraceEventType.Warning, CAT_DEFAULT, "Not able to rollback AD create for UID: " + uid.GetUidValue());
                    // note: this is not perfect, we hide the original exception
                    throw;
                }

                // rethrow original exception
                throw;
            }

            context.Uid = uid;
        }