コード例 #1
0
 public void SaveSettings(PackageSettings settings)
 {
     settings["ChildSpacesFolder"] = txtSpacesFolder.Text.Trim();
 }
コード例 #2
0
 public void BindSettings(PackageSettings settings)
 {
     domainsList.Value = settings["NameServers"];
 }
コード例 #3
0
 public void SaveSettings(PackageSettings settings)
 {
     settings["InstantAlias"] = txtInstantAlias.Text.Trim();
 }
コード例 #4
0
		public void BindSettings(PackageSettings settings)
		{
            temporaryDomain.Text = settings["temporaryDomain"];
            ecpURL.Text = settings["ecpURL"];
		}
コード例 #5
0
		public void SaveSettings(PackageSettings settings)
		{
			settings["TempDomain"] = txtTempDomain.Text.Trim();
		}
コード例 #6
0
        public static int UpdatePackageSettings(PackageSettings settings)
        {
            // check account
            int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo);
            if (accountCheck < 0) return accountCheck;

            //// get user details
            //UserInfo user = GetUserInternally(settings.UserId);

            //// place log record
            //LogRecord record = new LogRecord();
            //record.RecordType = LogRecordType.Information;
            //record.PackageId = 0;
            //record.ItemId = settings.UserId;
            //record.Source = LogSource.USERS;
            //record.Action = "USERS_UPDATE_USER_SETTINGS";
            //record.ActionParameters.Add(user.Username).Add(settings.SettingsName);

            try
            {
                // build xml
                XmlDocument doc = new XmlDocument();
                XmlElement nodeProps = doc.CreateElement("properties");
                if (settings.SettingsArray != null)
                {
                    foreach (string[] pair in settings.SettingsArray)
                    {
                        XmlElement nodeProp = doc.CreateElement("property");
                        nodeProp.SetAttribute("name", pair[0]);
                        nodeProp.SetAttribute("value", pair[1]);
                        nodeProps.AppendChild(nodeProp);
                    }
                }

                string xml = nodeProps.OuterXml;

                // update settings
                DataProvider.UpdatePackageSettings(SecurityContext.User.UserId,
                    settings.PackageId, settings.SettingsName, xml);

                return 0;
            }
            catch (Exception ex)
            {
                //record.RecordType = LogRecordType.Error;
                //record.Description["Error"] = ex.ToString();
                throw new Exception("Could not update package settings", ex);
            }
            //finally
            //{
            //    AuditLog.AddRecord(record);
            //}
        }
コード例 #7
0
 public int UpdatePackageSettings(PackageSettings settings) {
     object[] results = this.Invoke("UpdatePackageSettings", new object[] {
                 settings});
     return ((int)(results[0]));
 }
コード例 #8
0
 public void SaveSettings(PackageSettings settings)
 {
     settings["HostnamePattern"] = txtHostnamePattern.Text.Trim();
 }
コード例 #9
0
 public void SaveSettings(PackageSettings settings)
 {
     settings["SharedSslSites"] = domainsList.Value;
 }
コード例 #10
0
        public static int AddZone(int packageId, int serviceId, string zoneName, bool addPackageItem)
        {
            // get DNS provider
            DNSServer dns = GetDNSServer(serviceId);

            // check if zone already exists
            if (dns.ZoneExists(zoneName))
            {
                return(BusinessErrorCodes.ERROR_DNS_ZONE_EXISTS);
            }

            //
            TaskManager.StartTask("DNS_ZONE", "ADD", zoneName);
            //
            int zoneItemId = default(int);

            //
            try
            {
                // get secondary DNS services
                StringDictionary primSettings       = ServerController.GetServiceSettings(serviceId);
                string[]         primaryIPAddresses = GetExternalIPAddressesFromString(primSettings["ListeningIPAddresses"]);

                List <string> secondaryIPAddresses = new List <string>();
                List <int>    secondaryServiceIds  = new List <int>();
                string        strSecondaryServices = primSettings["SecondaryDNSServices"];
                if (!String.IsNullOrEmpty(strSecondaryServices))
                {
                    string[] secondaryServices = strSecondaryServices.Split(',');
                    foreach (string strSecondaryId in secondaryServices)
                    {
                        int secondaryId = Utils.ParseInt(strSecondaryId, 0);
                        if (secondaryId == 0)
                        {
                            continue;
                        }

                        secondaryServiceIds.Add(secondaryId);
                        StringDictionary secondarySettings = ServerController.GetServiceSettings(secondaryId);

                        // add secondary IPs to the master array
                        secondaryIPAddresses.AddRange(
                            GetExternalIPAddressesFromString(secondarySettings["ListeningIPAddresses"]));
                    }
                }

                // add "Allow zone transfers"
                string allowTransfers = primSettings["AllowZoneTransfers"];
                if (!String.IsNullOrEmpty(allowTransfers))
                {
                    string[] ips = Utils.ParseDelimitedString(allowTransfers, '\n', ' ', ',', ';');
                    foreach (string ip in ips)
                    {
                        if (!secondaryIPAddresses.Contains(ip))
                        {
                            secondaryIPAddresses.Add(ip);
                        }
                    }
                }

                // add primary zone
                dns.AddPrimaryZone(zoneName, secondaryIPAddresses.ToArray());

                // get DNS zone records
                List <GlobalDnsRecord> records = ServerController.GetDnsRecordsTotal(packageId);

                // get name servers
                PackageSettings packageSettings = PackageController.GetPackageSettings(packageId, PackageSettings.NAME_SERVERS);
                string[]        nameServers     = new string[] { };
                if (!String.IsNullOrEmpty(packageSettings["NameServers"]))
                {
                    nameServers = packageSettings["NameServers"].Split(';');
                }

                // build records list
                List <DnsRecord> zoneRecords = new List <DnsRecord>();

                string primaryNameServer = "ns." + zoneName;

                if (nameServers.Length > 0)
                {
                    primaryNameServer = nameServers[0];
                }

                // update SOA record

                string hostmaster = primSettings["ResponsiblePerson"];
                if (String.IsNullOrEmpty(hostmaster))
                {
                    hostmaster = "hostmaster." + zoneName;
                }
                else
                {
                    hostmaster = Utils.ReplaceStringVariable(hostmaster, "domain_name", zoneName);
                }

                dns.UpdateSoaRecord(zoneName, "", primaryNameServer, hostmaster);

                // add name servers
                foreach (string nameServer in nameServers)
                {
                    DnsRecord ns = new DnsRecord();
                    ns.RecordType = DnsRecordType.NS;
                    ns.RecordName = "";
                    ns.RecordData = nameServer;

                    zoneRecords.Add(ns);
                }

                // add all other records
                zoneRecords.AddRange(
                    BuildDnsResourceRecords(records, zoneName, ""));

                // add zone records
                dns.AddZoneRecords(zoneName, zoneRecords.ToArray());


                // add secondary zones
                foreach (int secondaryId in secondaryServiceIds)
                {
                    try
                    {
                        // add secondary zone
                        DNSServer secDns = GetDNSServer(secondaryId);
                        secDns.AddSecondaryZone(zoneName, primaryIPAddresses);
                        RegisterZoneItems(packageId, secondaryId, zoneName, false);
                    }
                    catch (Exception ex)
                    {
                        TaskManager.WriteError(ex, "Error adding secondary zone (service ID = " + secondaryId + ")");
                    }
                }

                if (!addPackageItem)
                {
                    return(0);
                }
                // add service item
                zoneItemId = RegisterZoneItems(packageId, serviceId, zoneName, true);
                //
                TaskManager.ItemId = zoneItemId;
            }
            catch (Exception ex)
            {
                TaskManager.WriteError(ex);
            }
            finally
            {
                TaskManager.CompleteTask();
            }
            //
            return(zoneItemId);
        }
コード例 #11
0
 public void BindSettings(PackageSettings settings)
 {
     domainsList.Value = settings["SharedSslSites"];
 }
コード例 #12
0
        public static IntResult CreateOrganization(int packageId, string organizationId,
                                                   string domain, string adminName, string adminEmail, string adminPassword)
        {
            IntResult result = new IntResult();

            result.IsSuccess = true;

            try
            {
                // initialize task manager
                TaskManager.StartTask(TaskManagerSource, "CREATE_ORGANIZATION");
                TaskManager.WriteParameter("packageId", packageId);
                TaskManager.WriteParameter("organizationId", organizationId);
                TaskManager.WriteParameter("domain", domain);
                TaskManager.WriteParameter("adminName", adminName);
                TaskManager.WriteParameter("adminEmail", adminEmail);
                TaskManager.WriteParameter("adminPassword", adminPassword);

                // get Exchange service ID
                int serviceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.ExchangeHostedEdition);
                if (serviceId < 1)
                {
                    return(Error <IntResult>(ExchangeServiceNotEnabledError));
                }

                #region Check Space and Account
                // Check account
                int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
                if (accountCheck < 0)
                {
                    return(Warning <IntResult>((-accountCheck).ToString()));
                }

                // Check space
                int packageCheck = SecurityContext.CheckPackage(packageId, DemandPackage.IsActive);
                if (packageCheck < 0)
                {
                    return(Warning <IntResult>((-packageCheck).ToString()));
                }
                #endregion

                // get Exchange service
                ExchangeServerHostedEdition exchange = GetExchangeService(serviceId);

                // load service settings to know ProgramID, OfferID
                StringDictionary serviceSettings = ServerController.GetServiceSettings(serviceId);
                string           programId       = serviceSettings["programID"];
                string           offerId         = serviceSettings["offerID"];

                // check settings
                if (String.IsNullOrEmpty(programId))
                {
                    result.ErrorCodes.Add(ProgramIdIsNotSetError);
                }
                if (String.IsNullOrEmpty(offerId))
                {
                    result.ErrorCodes.Add(OfferIdIsNotSetError);
                }

                if (result.ErrorCodes.Count > 0)
                {
                    result.IsSuccess = false;
                    return(result);
                }

                #region Create organization
                int itemId = -1;
                ExchangeOrganization org = null;
                try
                {
                    // create organization
                    exchange.CreateOrganization(organizationId, programId, offerId, domain, adminName, adminEmail, adminPassword);

                    // save item into meta-base
                    org           = new ExchangeOrganization();
                    org.Name      = organizationId;
                    org.PackageId = packageId;
                    org.ServiceId = serviceId;
                    itemId        = PackageController.AddPackageItem(org);
                }
                catch (Exception ex)
                {
                    // log error
                    TaskManager.WriteError(ex);
                    return(Error <IntResult>(CreateOrganizationError));
                }
                #endregion

                #region Update organization quotas
                // update max org quotas
                UpdateOrganizationQuotas(org);

                // override quotas
                ResultObject quotasResult = ExchangeHostedEditionController.UpdateOrganizationQuotas(itemId,
                                                                                                     org.MaxMailboxCountQuota,
                                                                                                     org.MaxContactCountQuota,
                                                                                                     org.MaxDistributionListCountQuota);

                if (!quotasResult.IsSuccess)
                {
                    return(Error <IntResult>(quotasResult, CreateOrganizationError));
                }
                #endregion

                #region Add temporary domain
                // load settings
                PackageSettings settings           = GetExchangePackageSettings(org);
                string          tempDomainTemplate = settings[TempDomainSetting];
                if (!String.IsNullOrEmpty(tempDomainTemplate))
                {
                    // add temp domain
                    string tempDomain = String.Format("{0}.{1}", domain, tempDomainTemplate);
                    AddOrganizationDomain(itemId, tempDomain);
                }

                #endregion

                result.Value = itemId;
                return(result);
            }
            catch (Exception ex)
            {
                // log error
                TaskManager.WriteError(ex);

                // exit with error code
                return(Error <IntResult>(GeneralError, ex.Message));
            }
            finally
            {
                TaskManager.CompleteTask();
            }
        }
コード例 #13
0
        public static ExchangeOrganization GetOrganizationDetails(int itemId)
        {
            // load organization item
            ExchangeOrganization item = PackageController.GetPackageItem(itemId) as ExchangeOrganization;

            if (item == null)
            {
                return(null); // organization item not found
            }
            // get Exchange service
            ExchangeServerHostedEdition exchange = GetExchangeService(item.ServiceId);

            // get organization details
            ExchangeOrganization org = exchange.GetOrganizationDetails(item.Name);

            //ExchangeOrganization org = new ExchangeOrganization
            //{
            //    Id = item.Id,
            //    PackageId = item.PackageId,
            //    ServiceId = item.ServiceId,
            //    Name = item.Name,
            //    AdministratorEmail = "*****@*****.**",
            //    AdministratorName = "Administrator Mailbox",
            //    CatchAllAddress = "",
            //    ContactCount = 1,
            //    ContactCountQuota = 2,
            //    MaxContactCountQuota = 3,
            //    DistinguishedName = "DN=....",
            //    DistributionListCount = 2,
            //    DistributionListCountQuota = 3,
            //    MaxDistributionListCountQuota = 3,
            //    MaxDomainsCountQuota = 4,
            //    ExchangeControlPanelUrl = "http://ecp.domain.com",
            //    MailboxCount = 3,
            //    MailboxCountQuota = 4,
            //    MaxMailboxCountQuota = 4,
            //    ProgramId = "HostedExchange",
            //    OfferId = "2",
            //    ServicePlan = "HostedExchange_Basic",
            //    Domains = GetOrganizationDomains(item.Id).ToArray()
            //};

            // update item props
            org.Id              = item.Id;
            org.PackageId       = item.PackageId;
            org.ServiceId       = item.ServiceId;
            org.Name            = item.Name;
            org.CatchAllAddress = item.CatchAllAddress;

            // update max quotas
            UpdateOrganizationQuotas(org);

            // process summary information
            org.SummaryInformation = GetExchangeOrganizationSummary(org);

            // process domains
            PackageSettings settings = GetExchangePackageSettings(org);

            if (settings != null)
            {
                // get settings
                string tempDomain = settings[TempDomainSetting];
                string ecpUrl     = settings[ExchangeControlPanelUrlSetting];

                // iterate through domains
                foreach (ExchangeOrganizationDomain domain in org.Domains)
                {
                    if (tempDomain != null && domain.Name.EndsWith("." + tempDomain, StringComparison.InvariantCultureIgnoreCase))
                    {
                        domain.IsTemp = true;
                    }
                    if (domain.IsDefault && ecpUrl != null)
                    {
                        org.ExchangeControlPanelUrl = Utils.ReplaceStringVariable(ecpUrl, "domain_name", domain.Name);
                    }
                }
            }

            // return org
            return(org);
        }
コード例 #14
0
 public void SaveSettings(PackageSettings settings)
 {
     settings["NameServers"] = domainsList.Value;
 }
コード例 #15
0
 /// <remarks/>
 public System.IAsyncResult BeginUpdatePackageSettings(PackageSettings settings, System.AsyncCallback callback, object asyncState) {
     return this.BeginInvoke("UpdatePackageSettings", new object[] {
                 settings}, callback, asyncState);
 }
コード例 #16
0
 public void BindSettings(PackageSettings settings)
 {
     txtHostnamePattern.Text = settings["HostnamePattern"];
 }
コード例 #17
0
 /// <remarks/>
 public void UpdatePackageSettingsAsync(PackageSettings settings) {
     this.UpdatePackageSettingsAsync(settings, null);
 }
コード例 #18
0
		public void BindSettings(PackageSettings settings)
		{
			txtTempDomain.Text = settings["TempDomain"];
		}
コード例 #19
0
 /// <remarks/>
 public void UpdatePackageSettingsAsync(PackageSettings settings, object userState) {
     if ((this.UpdatePackageSettingsOperationCompleted == null)) {
         this.UpdatePackageSettingsOperationCompleted = new System.Threading.SendOrPostCallback(this.OnUpdatePackageSettingsOperationCompleted);
     }
     this.InvokeAsync("UpdatePackageSettings", new object[] {
                 settings}, this.UpdatePackageSettingsOperationCompleted, userState);
 }
コード例 #20
0
        public static PackageSettings GetPackageSettings(int packageId, string settingsName)
        {
            IDataReader reader = DataProvider.GetPackageSettings(
                SecurityContext.User.UserId, packageId, settingsName);

            PackageSettings settings = new PackageSettings();
            settings.PackageId = packageId;
            settings.SettingsName = settingsName;

            while (reader.Read())
            {
                settings.PackageId = (int)reader["PackageID"];
                settings[(string)reader["PropertyName"]] = (string)reader["PropertyValue"];
            }
            reader.Close();

            // set root settings if required
            if (settings.PackageId < 2)
            {
                // instant alias
                if (String.Compare(PackageSettings.INSTANT_ALIAS, settingsName, true) == 0)
                {
                    // load package info
                    PackageInfo package = GetPackage(packageId);

                    // load package server
                    ServerInfo srv = ServerController.GetServerByIdInternal(package.ServerId);
                    if (srv != null)
                        settings["InstantAlias"] = srv.InstantDomainAlias;
                }

                // name servers
                else if (String.Compare(PackageSettings.NAME_SERVERS, settingsName, true) == 0)
                {
                    // load DNS service settings
                    int dnsServiceId = GetPackageServiceId(packageId, ResourceGroups.Dns);
                    if (dnsServiceId > 0)
                    {
                        StringDictionary dnsSettings = ServerController.GetServiceSettings(dnsServiceId);
                        settings["NameServers"] = dnsSettings["NameServers"];
                    }
                }

                // shared SSL sites
                else if (String.Compare(PackageSettings.SHARED_SSL_SITES, settingsName, true) == 0)
                {
                    // load WEB service settings
                    int webServiceId = GetPackageServiceId(packageId, ResourceGroups.Web);
                    if (webServiceId > 0)
                    {
                        StringDictionary webSettings = ServerController.GetServiceSettings(webServiceId);
                        settings["SharedSslSites"] = webSettings["SharedSslSites"];
                    }
                }

                // child spaces location
                else if (String.Compare(PackageSettings.SPACES_FOLDER, settingsName, true) == 0)
                {
                    settings["ChildSpacesFolder"] = "";
                }

                // Exchange Server
                else if (String.Compare(PackageSettings.EXCHANGE_SERVER, settingsName, true) == 0)
                {
                    // load Exchange service settings
                    int exchServiceId = GetPackageServiceId(packageId, ResourceGroups.Exchange);
                    if (exchServiceId > 0)
                    {
                        StringDictionary exchSettings = ServerController.GetServiceSettings(exchServiceId);
                        settings["TempDomain"] = exchSettings["TempDomain"];
                    }
                }

                // Exchange Hosted Edition
                else if (String.Compare(PackageSettings.EXCHANGE_HOSTED_EDITION, settingsName, true) == 0)
                {
                    // load Exchange service settings
                    int exchServiceId = GetPackageServiceId(packageId, ResourceGroups.ExchangeHostedEdition);
                    if (exchServiceId > 0)
                    {
                        StringDictionary exchSettings = ServerController.GetServiceSettings(exchServiceId);
                        settings["temporaryDomain"] = exchSettings["temporaryDomain"];
                        settings["ecpURL"] = exchSettings["ecpURL"];
                    }
                }

                // VPS
                else if (String.Compare(PackageSettings.VIRTUAL_PRIVATE_SERVERS, settingsName, true) == 0)
                {
                    // load Exchange service settings
                    int vpsServiceId = GetPackageServiceId(packageId, ResourceGroups.VPS);
                    if (vpsServiceId > 0)
                    {
                        StringDictionary vpsSettings = ServerController.GetServiceSettings(vpsServiceId);
                        settings["HostnamePattern"] = vpsSettings["HostnamePattern"];
                    }
                }
            }

            return settings;
        }
コード例 #21
0
        private void SaveSettings()
        {
            try
            {
                PackageSettings settings = new PackageSettings();
                settings.PackageId = PanelSecurity.PackageId;
                settings.SettingsName = SettingsName;

                // set properties
                if (ddlOverride.SelectedIndex == 1)
                {
                    // gather settings from the control
                    // if overriden
                    ctlSettings.SaveSettings(settings);
                }

                int result = ES.Services.Packages.UpdatePackageSettings(settings);
                if (result < 0)
                {
                    ShowResultMessage(result);
                    return;
                }

                ReturnBack();
            }
            catch (Exception ex)
            {
                ShowErrorMessage("PACKAGE_SETTINGS_UPDATE", ex);
                return;
            }
        }
コード例 #22
0
 public void BindSettings(PackageSettings settings)
 {
     txtInstantAlias.Text = settings["InstantAlias"];
 }
コード例 #23
0
        protected void ddlOverride_SelectedIndexChanged(object sender, EventArgs e)
        {
            if (ddlOverride.SelectedIndex == 0) // use host settings
            {
                // delete current settings
                PackageSettings settings = new PackageSettings();
                settings.PackageId = PanelSecurity.PackageId;
                settings.SettingsName = SettingsName;
                ES.Services.Packages.UpdatePackageSettings(settings);

                // rebind settings
                BindSettings();
            }
            else
            {
                ToggleControls();
            }
        }
コード例 #24
0
 public int UpdatePackageSettings(PackageSettings settings)
 {
     return PackageController.UpdatePackageSettings(settings);
 }
コード例 #25
0
 public int UpdatePackageSettings(PackageSettings settings)
 {
     return(PackageController.UpdatePackageSettings(settings));
 }
コード例 #26
0
		public void SaveSettings(PackageSettings settings)
		{
            settings["temporaryDomain"] = temporaryDomain.Text.Trim();
            settings["ecpURL"] = ecpURL.Text.Trim();
		}
コード例 #27
0
 public void BindSettings(PackageSettings settings)
 {
     txtSpacesFolder.Text = settings["ChildSpacesFolder"];
 }