Esempio n. 1
0
        internal override string CreateMailEnableUserInternal(string upn, string organizationId, string organizationDistinguishedName,
                                                              ExchangeAccountType accountType,
                                                              string mailboxDatabase, string offlineAddressBook, string addressBookPolicy,
                                                              string accountName, bool enablePOP, bool enableIMAP,
                                                              bool enableOWA, bool enableMAPI, bool enableActiveSync,
                                                              long issueWarningKB, long prohibitSendKB, long prohibitSendReceiveKB, int keepDeletedItemsDays,
                                                              int maxRecipients, int maxSendMessageSizeKB, int maxReceiveMessageSizeKB, bool hideFromAddressBook, bool IsConsumer, bool enabledLitigationHold, long recoverabelItemsSpace, long recoverabelItemsWarning)
        {
            ExchangeLog.LogStart("CreateMailEnableUserInternal");
            ExchangeLog.DebugInfo("Organization Id: {0}", organizationId);

            string ret = null;
            ExchangeTransaction transaction = StartTransaction();
            Runspace            runSpace    = null;

            int    attempts = 0;
            string id       = null;

            try
            {
                runSpace = OpenRunspace();
                Command cmd = null;
                Collection <PSObject> result = null;

                //try to enable mail user for 10 times
                while (true)
                {
                    try
                    {
                        //create mailbox
                        cmd = new Command("Enable-Mailbox");
                        cmd.Parameters.Add("Identity", upn);
                        cmd.Parameters.Add("Alias", accountName);
                        string database = GetDatabase(runSpace, PrimaryDomainController, mailboxDatabase);
                        ExchangeLog.DebugInfo("database: " + database);
                        if (database != string.Empty)
                        {
                            cmd.Parameters.Add("Database", database);
                        }
                        if (accountType == ExchangeAccountType.Equipment)
                        {
                            cmd.Parameters.Add("Equipment");
                        }
                        else if (accountType == ExchangeAccountType.Room)
                        {
                            cmd.Parameters.Add("Room");
                        }
                        else if (accountType == ExchangeAccountType.SharedMailbox)
                        {
                            cmd.Parameters.Add("Shared");
                        }

                        result = ExecuteShellCommand(runSpace, cmd);

                        id = CheckResultObjectDN(result);
                    }
                    catch (Exception ex)
                    {
                        ExchangeLog.LogError(ex);
                    }
                    if (id != null)
                    {
                        break;
                    }

                    if (attempts > 9)
                    {
                        throw new Exception(
                                  string.Format("Could not enable mail user '{0}' ", upn));
                    }

                    attempts++;
                    ExchangeLog.LogWarning("Attempt #{0} to enable mail user failed!", attempts);
                    // wait 5 sec
                    System.Threading.Thread.Sleep(1000);
                }

                transaction.RegisterEnableMailbox(id);

                string windowsEmailAddress = ObjToString(GetPSObjectProperty(result[0], "WindowsEmailAddress"));

                //update mailbox
                cmd = new Command("Set-Mailbox");
                cmd.Parameters.Add("Identity", id);
                cmd.Parameters.Add("OfflineAddressBook", offlineAddressBook);
                cmd.Parameters.Add("EmailAddressPolicyEnabled", false);
                cmd.Parameters.Add("CustomAttribute1", organizationId);
                cmd.Parameters.Add("CustomAttribute3", windowsEmailAddress);
                cmd.Parameters.Add("PrimarySmtpAddress", upn);
                cmd.Parameters.Add("WindowsEmailAddress", upn);

                cmd.Parameters.Add("UseDatabaseQuotaDefaults", new bool?(false));
                cmd.Parameters.Add("UseDatabaseRetentionDefaults", false);
                cmd.Parameters.Add("IssueWarningQuota", ConvertKBToUnlimited(issueWarningKB));
                cmd.Parameters.Add("ProhibitSendQuota", ConvertKBToUnlimited(prohibitSendKB));
                cmd.Parameters.Add("ProhibitSendReceiveQuota", ConvertKBToUnlimited(prohibitSendReceiveKB));
                cmd.Parameters.Add("RetainDeletedItemsFor", ConvertDaysToEnhancedTimeSpan(keepDeletedItemsDays));
                cmd.Parameters.Add("RecipientLimits", ConvertInt32ToUnlimited(maxRecipients));
                cmd.Parameters.Add("MaxSendSize", ConvertKBToUnlimited(maxSendMessageSizeKB));
                cmd.Parameters.Add("MaxReceiveSize", ConvertKBToUnlimited(maxReceiveMessageSizeKB));
                if (IsConsumer)
                {
                    cmd.Parameters.Add("HiddenFromAddressListsEnabled", true);
                }
                else
                {
                    cmd.Parameters.Add("HiddenFromAddressListsEnabled", hideFromAddressBook);
                }
                cmd.Parameters.Add("AddressBookPolicy", addressBookPolicy);

                if (enabledLitigationHold)
                {
                    cmd.Parameters.Add("LitigationHoldEnabled", true);
                    cmd.Parameters.Add("RecoverableItemsQuota", ConvertKBToUnlimited(recoverabelItemsSpace));
                    cmd.Parameters.Add("RecoverableItemsWarningQuota", ConvertKBToUnlimited(recoverabelItemsWarning));
                }

                ExecuteShellCommand(runSpace, cmd);

                //Client Access
                cmd = new Command("Set-CASMailbox");
                cmd.Parameters.Add("Identity", id);
                cmd.Parameters.Add("ActiveSyncEnabled", enableActiveSync);
                if (enableActiveSync)
                {
                    cmd.Parameters.Add("ActiveSyncMailboxPolicy", organizationId);
                }
                cmd.Parameters.Add("OWAEnabled", enableOWA);
                cmd.Parameters.Add("MAPIEnabled", enableMAPI);
                cmd.Parameters.Add("PopEnabled", enablePOP);
                cmd.Parameters.Add("ImapEnabled", enableIMAP);
                ExecuteShellCommand(runSpace, cmd);

                //calendar settings
                if (accountType == ExchangeAccountType.Equipment || accountType == ExchangeAccountType.Room)
                {
                    SetCalendarSettings(runSpace, id);
                }

                //add to the security group
                cmd = new Command("Add-DistributionGroupMember");
                cmd.Parameters.Add("Identity", organizationId);
                cmd.Parameters.Add("Member", id);
                cmd.Parameters.Add("BypassSecurityGroupManagerCheck", true);
                ExecuteShellCommand(runSpace, cmd);

                cmd = new Command("Set-MailboxFolderPermission");
                cmd.Parameters.Add("Identity", id + ":\\calendar");
                cmd.Parameters.Add("AccessRights", "None");
                cmd.Parameters.Add("User", "Default");
                ExecuteShellCommand(runSpace, cmd);

                ret = string.Format("{0}\\{1}", GetNETBIOSDomainName(), accountName);
                ExchangeLog.LogEnd("CreateMailEnableUserInternal");
                return(ret);
            }
            catch (Exception ex)
            {
                ExchangeLog.LogError("CreateMailEnableUserInternal", ex);
                RollbackTransaction(transaction);
                throw;
            }
            finally
            {
                CloseRunspace(runSpace);
            }
        }
Esempio n. 2
0
        private string CreateUserInternal(string userUpn, string userDistinguishedName)
        {
            HostedSolutionLog.LogStart("CreateUserInternal");
            HostedSolutionLog.DebugInfo("UPN: {0}", userUpn);
            HostedSolutionLog.DebugInfo("User Distinguished Name: {0}", userDistinguishedName);

            try
            {
                if (string.IsNullOrEmpty(userUpn))
                {
                    throw new ArgumentException("userUpn");
                }

                if (string.IsNullOrEmpty(userDistinguishedName))
                {
                    throw new ArgumentException("userDistinguishedName");
                }

                if (string.IsNullOrEmpty(PoolFQDN))
                {
                    throw new Exception("Pool FQDN is not specified");
                }



                string poolDN = GetPoolDistinguishedName(PoolFQDN);
                if (string.IsNullOrEmpty(poolDN))
                {
                    throw new Exception(string.Format("Pool {0} not found", PoolFQDN));
                }

                if (!string.IsNullOrEmpty(FindUserByDistinguishedName(userDistinguishedName)))
                {
                    throw new Exception(string.Format("User with distinguished name '{0}' already exists", userDistinguishedName));
                }

                string primaryUri = "sip:" + userUpn;

                if (!string.IsNullOrEmpty(FindUserByPrimaryUri(primaryUri)))
                {
                    throw new Exception(string.Format("User with primary URI '{0}' already exists", primaryUri));
                }

                using (ManagementObject newUser = Wmi.CreateInstance("MSFT_SIPESUserSetting"))
                {
                    newUser["PrimaryURI"]               = primaryUri;
                    newUser["UserDN"]                   = userDistinguishedName;
                    newUser["HomeServerDN"]             = poolDN;
                    newUser["Enabled"]                  = true;
                    newUser["EnabledForInternetAccess"] = true;
                    newUser.Put();
                }
                string instanceId = null;
                int    attempts   = 0;
                while (true)
                {
                    instanceId = FindUserByPrimaryUri(primaryUri);
                    if (!string.IsNullOrEmpty(instanceId))
                    {
                        break;
                    }

                    if (attempts > 9)
                    {
                        throw new Exception(
                                  string.Format("Could not find OCS user '{0}'", primaryUri));
                    }

                    attempts++;
                    ExchangeLog.LogWarning("Attempt #{0} to create OCS user failed!", attempts);
                    // wait 30 sec
                    System.Threading.Thread.Sleep(1000);
                }

                HostedSolutionLog.LogEnd("CreateUserInternal");

                return(instanceId);
            }
            catch (Exception ex)
            {
                HostedSolutionLog.LogError("CreateUserInternal", ex);
                throw;
            }
        }