1017 lines
38 KiB
C#
1017 lines
38 KiB
C#
// Copyright (c) 2012, Outercurve Foundation.
|
|
// All rights reserved.
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
// are permitted provided that the following conditions are met:
|
|
//
|
|
// - Redistributions of source code must retain the above copyright notice, this
|
|
// list of conditions and the following disclaimer.
|
|
//
|
|
// - Redistributions in binary form must reproduce the above copyright notice,
|
|
// this list of conditions and the following disclaimer in the documentation
|
|
// and/or other materials provided with the distribution.
|
|
//
|
|
// - Neither the name of the Outercurve Foundation nor the names of its
|
|
// contributors may be used to endorse or promote products derived from this
|
|
// software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
|
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.Data;
|
|
using WebsitePanel.Providers.Common;
|
|
using WebsitePanel.Providers.CRM;
|
|
using WebsitePanel.Providers.DNS;
|
|
using WebsitePanel.Providers.HostedSolution;
|
|
using WebsitePanel.Providers.ResultObjects;
|
|
|
|
namespace WebsitePanel.EnterpriseServer
|
|
{
|
|
public class CRMController
|
|
{
|
|
private static CRM GetCRMProxy(int packageId)
|
|
{
|
|
int crmServiceId = GetCRMServiceId(packageId);
|
|
CRM ws = new CRM();
|
|
ServiceProviderProxy.Init(ws, crmServiceId);
|
|
return ws;
|
|
}
|
|
|
|
private static int GetCRMServiceId(int packageId)
|
|
{
|
|
int serviceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.HostedCRM);
|
|
return serviceId;
|
|
}
|
|
|
|
|
|
private static ResultObject CreateDnsZoneRecord(int domainId, string recordName, string ip)
|
|
{
|
|
ResultObject ret = StartTask<ResultObject>("CRM", "CREATE_DNS_ZONE");
|
|
|
|
try
|
|
{
|
|
//check for existing empty A record
|
|
DnsRecord[] records = ServerController.GetDnsZoneRecords(domainId);
|
|
foreach (DnsRecord record in records)
|
|
{
|
|
if ((record.RecordType == DnsRecordType.A || record.RecordType == DnsRecordType.AAAA) && (String.Compare(recordName, record.RecordName, true) == 0))
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CANNOT_CREATE_DNS_ZONE, null,
|
|
string.Format("DNS record already exists. DomainId={0}, RecordName={1}", domainId, recordName));
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
var type = ip.Contains(":") ? DnsRecordType.AAAA : DnsRecordType.A;
|
|
int res = ServerController.AddDnsZoneRecord(domainId, recordName, type, ip, 0, 0, 0, 0);
|
|
if (res != 0)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CANNOT_CREATE_DNS_ZONE, null,
|
|
string.Format("Cannot create dns record. DomainId={0}, IP={1}, ErrorCode={2}, RecordName={3}", domainId, ip, res, recordName));
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CANNOT_CREATE_DNS_ZONE, ex);
|
|
return ret;
|
|
}
|
|
|
|
CompleteTask();
|
|
return ret;
|
|
}
|
|
|
|
private static ValueResultObject<DomainInfo> CreateOrganizationDomain(Organization org)
|
|
{
|
|
ValueResultObject<DomainInfo> ret = StartTask<ValueResultObject<DomainInfo>>("CRM", "CREATE_ORGANIZATIO_DOMAIN");
|
|
try
|
|
{
|
|
int dnsServiceId = PackageController.GetPackageServiceId(org.PackageId, ResourceGroups.Dns);
|
|
if (dnsServiceId <= 0)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.DNS_SERVER_IS_NOT_SELECTED_IN_HOSTIN_PLAN, null,
|
|
string.Format("DNS Server is not selected in hosting plan."));
|
|
|
|
return ret;
|
|
}
|
|
|
|
int crmServiceId = GetCRMServiceId(org.PackageId);
|
|
StringDictionary serviceSettings = ServerController.GetServiceSettings(crmServiceId);
|
|
|
|
string strDomainName = string.Format("{0}.{1}", org.OrganizationId,
|
|
serviceSettings[Constants.IFDWebApplicationRootDomain]);
|
|
|
|
DomainInfo domain = ServerController.GetDomain(strDomainName);
|
|
|
|
if (domain == null)
|
|
{
|
|
domain = new DomainInfo();
|
|
domain.PackageId = org.PackageId;
|
|
domain.DomainName = strDomainName;
|
|
|
|
domain.IsInstantAlias = false;
|
|
domain.IsSubDomain = false;
|
|
domain.DomainId = ServerController.AddDomain(domain);
|
|
|
|
}
|
|
|
|
ret.Value = domain;
|
|
|
|
if (domain.DomainId <= 0)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CANNOT_CREATE_CRM_ORGANIZATION_DOMAIN, null,
|
|
string.Format("Crm organization domain cannot be created. DomainId {0}", domain.DomainId));
|
|
return ret;
|
|
}
|
|
|
|
ResultObject resAddDnsZoneRecord = CreateDnsZoneRecord(domain.DomainId, string.Empty, serviceSettings[Constants.CRMWebsiteIP]);
|
|
ret.ErrorCodes.AddRange(resAddDnsZoneRecord.ErrorCodes);
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CREATE_CRM_ORGANIZATION_DOMAIN_GENERAL_ERROR, ex);
|
|
return ret;
|
|
}
|
|
|
|
CompleteTask();
|
|
return ret;
|
|
}
|
|
|
|
private static void CompleteTask(ResultObject res, string errorCode, Exception ex, string errorMessage)
|
|
{
|
|
if (res != null)
|
|
{
|
|
res.IsSuccess = false;
|
|
|
|
if (!string.IsNullOrEmpty(errorCode))
|
|
res.ErrorCodes.Add(errorCode);
|
|
}
|
|
|
|
if (ex != null)
|
|
TaskManager.WriteError(ex);
|
|
|
|
if (!string.IsNullOrEmpty(errorMessage))
|
|
TaskManager.WriteError(errorMessage);
|
|
|
|
//LogRecord.
|
|
TaskManager.CompleteTask();
|
|
|
|
|
|
}
|
|
|
|
private static void CompleteTask(ResultObject res, string errorCode, Exception ex)
|
|
{
|
|
CompleteTask(res, errorCode, ex, null);
|
|
}
|
|
|
|
private static void CompleteTask(ResultObject res, string errorCode)
|
|
{
|
|
CompleteTask(res, errorCode, null, null);
|
|
}
|
|
|
|
private static void CompleteTask(ResultObject res)
|
|
{
|
|
CompleteTask(res, null);
|
|
}
|
|
|
|
private static void CompleteTask()
|
|
{
|
|
CompleteTask(null);
|
|
}
|
|
|
|
private static T StartTask<T>(string source, string taskName) where T : ResultObject, new()
|
|
{
|
|
TaskManager.StartTask(source, taskName);
|
|
T res = new T();
|
|
res.IsSuccess = true;
|
|
return res;
|
|
}
|
|
|
|
public static OrganizationResult CreateOrganization(int organizationId, string baseCurrencyCode, string baseCurrencyName, string baseCurrencySymbol, string regionName, int userId, string collation)
|
|
{
|
|
OrganizationResult res = StartTask<OrganizationResult>("CRM", "CREATE_ORGANIZATION");
|
|
|
|
try
|
|
{
|
|
Organization org = OrganizationController.GetOrganization(organizationId);
|
|
|
|
try
|
|
{
|
|
if (!CheckQuota(org.PackageId))
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.QUOTA_HAS_BEEN_REACHED);
|
|
return res;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CANNOT_CHECK_QUOTAS, ex);
|
|
return res;
|
|
}
|
|
|
|
CRM crm = GetCRMProxy(org.PackageId);
|
|
Guid orgId = Guid.NewGuid();
|
|
|
|
OrganizationUser user = OrganizationController.GetUserGeneralSettings(organizationId, userId);
|
|
|
|
if (string.IsNullOrEmpty(user.FirstName))
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.FIRST_NAME_IS_NOT_SPECIFIED);
|
|
return res;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(user.LastName))
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.LAST_NAME_IS_NOT_SPECIFIED);
|
|
return res;
|
|
}
|
|
|
|
|
|
org.CrmAdministratorId = user.AccountId;
|
|
org.CrmCurrency =
|
|
string.Join("|", new[] {baseCurrencyCode, baseCurrencyName, baseCurrencySymbol, regionName});
|
|
org.CrmCollation = collation;
|
|
org.CrmOrgState = (int) CrmOrganizationState.Enabled;
|
|
org.CrmOrganizationId = orgId;
|
|
|
|
OrganizationResult serverRes =
|
|
crm.CreateOrganization(orgId, org.OrganizationId, org.Name, baseCurrencyCode, baseCurrencyName,
|
|
baseCurrencySymbol, user.SamAccountName, user.FirstName, user.LastName, user.PrimaryEmailAddress,
|
|
collation);
|
|
|
|
if (!serverRes.IsSuccess)
|
|
{
|
|
res.ErrorCodes.AddRange(serverRes.ErrorCodes);
|
|
CompleteTask(res);
|
|
return res;
|
|
}
|
|
|
|
ValueResultObject<DomainInfo> resDomain = CreateOrganizationDomain(org);
|
|
res.ErrorCodes.AddRange(resDomain.ErrorCodes);
|
|
|
|
|
|
int crmServiceId = GetCRMServiceId(org.PackageId);
|
|
|
|
StringDictionary serviceSettings = ServerController.GetServiceSettings(crmServiceId);
|
|
string port = serviceSettings[Constants.Port];
|
|
string schema = serviceSettings[Constants.UrlSchema];
|
|
if (port == "80" && schema == "http")
|
|
port = string.Empty;
|
|
|
|
if (port == "443" && schema == "https")
|
|
port = string.Empty;
|
|
|
|
if (port != string.Empty)
|
|
port = ":" + port;
|
|
|
|
string strDomainName = string.Format("{0}.{1}", org.OrganizationId,
|
|
serviceSettings[Constants.IFDWebApplicationRootDomain]);
|
|
org.CrmUrl = string.Format("{0}://{1}{2}", schema, strDomainName, port);
|
|
|
|
PackageController.UpdatePackageItem(org);
|
|
|
|
CrmUserResult crmUser = crm.GetCrmUserByDomainName(user.DomainUserName, org.OrganizationId);
|
|
res.ErrorCodes.AddRange(crmUser.ErrorCodes);
|
|
if (crmUser.IsSuccess)
|
|
{
|
|
try
|
|
{
|
|
DataProvider.CreateCRMUser(userId, crmUser.Value.CRMUserId, crmUser.Value.BusinessUnitId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CANNOT_ADD_ORGANIZATION_OWNER_TO_ORGANIZATIO_USER, ex, "Cannot add organization owner to organization users");
|
|
}
|
|
}
|
|
|
|
res.Value = org;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CREATE_CRM_ORGANIZATION_GENERAL_ERROR, ex);
|
|
return res;
|
|
}
|
|
|
|
CompleteTask();
|
|
return res;
|
|
}
|
|
|
|
public static StringArrayResultObject GetCollationNames(int packageId)
|
|
{
|
|
StringArrayResultObject ret = StartTask<StringArrayResultObject>("CRM", "GET_COLLATION_NAMES");
|
|
ret.IsSuccess = true;
|
|
|
|
try
|
|
{
|
|
int serviceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.HostedCRM);
|
|
if (serviceId == 0)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CRM_IS_NOT_SELECTED_IN_HOSTING_PLAN);
|
|
return ret;
|
|
}
|
|
|
|
CRM crm = new CRM();
|
|
ServiceProviderProxy.Init(crm, serviceId);
|
|
ret.Value = crm.GetSupportedCollationNames();
|
|
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CANNOT_GET_COLLATION_NAMES, ex);
|
|
return ret;
|
|
}
|
|
|
|
CompleteTask();
|
|
return ret;
|
|
}
|
|
|
|
public static CurrencyArrayResultObject GetCurrency(int packageId)
|
|
{
|
|
CurrencyArrayResultObject ret = StartTask<CurrencyArrayResultObject>("CRM", "GET_CURRENCY");
|
|
ret.IsSuccess = true;
|
|
try
|
|
{
|
|
int serviceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.HostedCRM);
|
|
if (serviceId == 0)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CRM_IS_NOT_SELECTED_IN_HOSTING_PLAN, null, "CRM is not selected in hosting plan.");
|
|
return ret;
|
|
}
|
|
|
|
CRM crm = new CRM();
|
|
ServiceProviderProxy.Init(crm, serviceId);
|
|
ret.Value = crm.GetCurrencyList();
|
|
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CANNOT_GET_CURRENCY_LIST, ex);
|
|
return ret;
|
|
}
|
|
CompleteTask();
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
private static ResultObject DeleteDnsRecord(int domainId, string recordName, string ip)
|
|
{
|
|
ResultObject ret = StartTask<ResultObject>("CRM", "DELETE_DNS_RECORD");
|
|
|
|
try
|
|
{
|
|
var type = ip.Contains(":") ? DnsRecordType.AAAA : DnsRecordType.A;
|
|
int res = ServerController.DeleteDnsZoneRecord(domainId, recordName, type, ip);
|
|
|
|
if (res != 0)
|
|
{
|
|
|
|
CompleteTask(ret, CrmErrorCodes.DELETE_DNS_RECORD_ERROR, null,
|
|
string.Format("Cannot delete dns record. DomainId={0}, DnsRecord={1}, ErrorCode={2}", domainId, DnsRecordType.A, res));
|
|
|
|
return ret;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CANNOT_DELETE_DNS_RECORD, ex);
|
|
return ret;
|
|
}
|
|
|
|
CompleteTask();
|
|
return ret;
|
|
|
|
}
|
|
|
|
private static ResultObject DeleteOrganizationDomain(Organization org)
|
|
{
|
|
ResultObject ret = StartTask<ResultObject>("CRM", "DELETE_ORGANIZATION_DOMAIN");
|
|
|
|
try
|
|
{
|
|
int dnsServiceId = PackageController.GetPackageServiceId(org.PackageId, ResourceGroups.Dns);
|
|
int crmServiceId = GetCRMServiceId(org.PackageId);
|
|
if (dnsServiceId <= 0)
|
|
{
|
|
TaskManager.WriteError("DNS Server is not selected in hosting plan.");
|
|
CompleteTask(ret, CrmErrorCodes.DNS_SERVER_IS_NOT_SELECTED_IN_HOSTIN_PLAN);
|
|
return ret;
|
|
}
|
|
|
|
StringDictionary serviceSettings = ServerController.GetServiceSettings(crmServiceId);
|
|
|
|
string domainName =
|
|
string.Format("{0}.{1}", org.OrganizationId, serviceSettings[Constants.IFDWebApplicationRootDomain]);
|
|
|
|
DomainInfo domainInfo = ServerController.GetDomain(domainName);
|
|
|
|
if (domainInfo == null)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CANNOT_GET_CRM_ORGANIZATION_DOMAIN, null,
|
|
string.Format("Cannot get crm organization domain {0}", domainName));
|
|
|
|
return ret;
|
|
}
|
|
|
|
ResultObject resultDeleteDnsRecord = DeleteDnsRecord(domainInfo.DomainId, string.Empty, serviceSettings[Constants.CRMWebsiteIP]);
|
|
ret.ErrorCodes.AddRange(resultDeleteDnsRecord.ErrorCodes);
|
|
if (!resultDeleteDnsRecord.IsSuccess)
|
|
{
|
|
CompleteTask(ret);
|
|
return ret;
|
|
}
|
|
|
|
/*try
|
|
{
|
|
ServerController.DeleteDomain(domainInfo.DomainId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CANNOT_DELETE_CRM_ORGANIZATIO_DOMAIN, ex);
|
|
return ret;
|
|
}*/
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.DELETE_CRM_ORGANIZATION_DOMAIN_GENERAL_ERROR, ex);
|
|
return ret;
|
|
}
|
|
|
|
CompleteTask();
|
|
return ret;
|
|
}
|
|
|
|
public static ResultObject DeleteOrganization(int organizationId)
|
|
{
|
|
ResultObject res = StartTask<ResultObject>("CRM", "DELETE_ORGANIZATION");
|
|
|
|
try
|
|
{
|
|
Organization org = OrganizationController.GetOrganization(organizationId);
|
|
CRM crm = GetCRMProxy(org.PackageId);
|
|
|
|
try
|
|
{
|
|
DataProvider.DeleteCrmOrganization(organizationId);
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CANNOT_DELETE_CRM_ORGANIZATION_METADATA, ex);
|
|
return res;
|
|
}
|
|
|
|
ResultObject resDeleteDomain = DeleteOrganizationDomain(org);
|
|
res.ErrorCodes.AddRange(resDeleteDomain.ErrorCodes);
|
|
|
|
|
|
ResultObject resDeleteOrganization = crm.DeleteOrganization(org.CrmOrganizationId);
|
|
res.ErrorCodes.AddRange(resDeleteOrganization.ErrorCodes);
|
|
if (!resDeleteOrganization.IsSuccess)
|
|
{
|
|
CompleteTask(res);
|
|
return res;
|
|
}
|
|
|
|
org.CrmAdministratorId = 0;
|
|
org.CrmCollation = string.Empty;
|
|
org.CrmCurrency = string.Empty;
|
|
org.CrmOrganizationId = Guid.Empty;
|
|
org.CrmOrgState = (int) CrmOrganizationState.Disabled;
|
|
org.CrmUrl = string.Empty;
|
|
|
|
PackageController.UpdatePackageItem(org);
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.DELETE_CRM_ORGANIZATION_GENERAL_ERROR, ex);
|
|
return res;
|
|
}
|
|
|
|
CompleteTask();
|
|
return res;
|
|
}
|
|
|
|
private static bool CheckQuota(int packageId)
|
|
{
|
|
TaskManager.StartTask("CRM", "CHECK_QUOTA");
|
|
bool res = false;
|
|
try
|
|
{
|
|
// check account
|
|
int errorCode = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
|
|
if (errorCode < 0) return false;
|
|
|
|
|
|
PackageContext cntx = PackageController.GetPackageContext(packageId);
|
|
return (cntx.Quotas[Quotas.CRM_ORGANIZATION] != null && !cntx.Quotas[Quotas.CRM_ORGANIZATION].QuotaExhausted);
|
|
|
|
|
|
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
TaskManager.WriteError(ex);
|
|
res = false;
|
|
|
|
}
|
|
finally
|
|
{
|
|
TaskManager.CompleteTask();
|
|
}
|
|
return res;
|
|
}
|
|
|
|
|
|
public static IntResult GetCRMUsersCount(int itemId, string name, string email)
|
|
{
|
|
IntResult res = StartTask<IntResult>("CRM", "GET_CRM_USERS_COUNT");
|
|
try
|
|
{
|
|
res.Value = DataProvider.GetCRMUsersCount(itemId, name, email);
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.GET_CRM_USER_COUNT, ex);
|
|
return res;
|
|
}
|
|
|
|
CompleteTask();
|
|
return res;
|
|
}
|
|
|
|
|
|
public static List<OrganizationUser> GetCRMOrganizationUsers(int itemId)
|
|
{
|
|
IDataReader reader =
|
|
DataProvider.GetCRMOrganizationUsers(itemId);
|
|
List<OrganizationUser> accounts = new List<OrganizationUser>();
|
|
ObjectUtils.FillCollectionFromDataReader(accounts, reader);
|
|
|
|
|
|
return accounts;
|
|
}
|
|
|
|
|
|
public static OrganizationUsersPagedResult GetCRMUsers(int itemId, string sortColumn, string sortDirection, string name, string email, int startRow, int count)
|
|
{
|
|
OrganizationUsersPagedResult res = StartTask<OrganizationUsersPagedResult>("CRM", "GET_CRM_USERS");
|
|
|
|
try
|
|
{
|
|
IDataReader reader =
|
|
DataProvider.GetCrmUsers(itemId, sortColumn, sortDirection, name, email, startRow, count);
|
|
List<OrganizationUser> accounts = new List<OrganizationUser>();
|
|
ObjectUtils.FillCollectionFromDataReader(accounts, reader);
|
|
res.Value = new OrganizationUsersPaged();
|
|
res.Value.PageUsers = accounts.ToArray();
|
|
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.GET_CRM_USERS, ex);
|
|
return res;
|
|
}
|
|
|
|
IntResult intRes = GetCRMUsersCount(itemId, name, email);
|
|
res.ErrorCodes.AddRange(intRes.ErrorCodes);
|
|
if (!intRes.IsSuccess)
|
|
{
|
|
CompleteTask(res);
|
|
return res;
|
|
}
|
|
res.Value.RecordsCount = intRes.Value;
|
|
|
|
CompleteTask();
|
|
return res;
|
|
}
|
|
|
|
|
|
public static UserResult CreateCRMUser(OrganizationUser user, int packageId, int itemId, Guid businessUnitId)
|
|
{
|
|
UserResult ret = StartTask<UserResult>("CRM", "CREATE_CRM_USER");
|
|
|
|
try
|
|
{
|
|
if (user == null)
|
|
throw new ArgumentNullException("user");
|
|
|
|
|
|
if (businessUnitId == Guid.Empty)
|
|
throw new ArgumentNullException("businessUnitId");
|
|
|
|
if (string.IsNullOrEmpty(user.FirstName))
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.FIRST_NAME_IS_NOT_SPECIFIED, null, "First name is not specified.");
|
|
return ret;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(user.LastName))
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.LAST_NAME_IS_NOT_SPECIFIED, null, "Last name is not specified.");
|
|
return ret;
|
|
}
|
|
|
|
Guid crmUserId = GetCrmUserId(user.AccountId);
|
|
|
|
if (crmUserId != Guid.Empty)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CRM_USER_ALREADY_EXISTS, null, "CRM user already exists.");
|
|
return ret;
|
|
}
|
|
|
|
|
|
BoolResult quotaRes = CheckQuota(packageId, itemId);
|
|
ret.ErrorCodes.AddRange(quotaRes.ErrorCodes);
|
|
if (!quotaRes.IsSuccess)
|
|
{
|
|
CompleteTask(ret);
|
|
return ret;
|
|
}
|
|
|
|
if (!quotaRes.Value)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.USER_QUOTA_HAS_BEEN_REACHED, null, "CRM user quota has been reached.");
|
|
return ret;
|
|
}
|
|
|
|
Guid crmId;
|
|
try
|
|
{
|
|
int serviceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.HostedCRM);
|
|
if (serviceId == 0)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CRM_IS_NOT_SELECTED_IN_HOSTING_PLAN, null, "CRM is not selected in hosting plan.");
|
|
return ret;
|
|
}
|
|
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
|
|
CRM crm = new CRM();
|
|
ServiceProviderProxy.Init(crm, serviceId);
|
|
|
|
UserResult res = crm.CreateCRMUser(user, org.OrganizationId, org.CrmOrganizationId, businessUnitId);
|
|
ret.ErrorCodes.AddRange(res.ErrorCodes);
|
|
|
|
if (!res.IsSuccess)
|
|
{
|
|
CompleteTask(res);
|
|
return ret;
|
|
}
|
|
crmId = res.Value.CrmUserId;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CANNOT_CREATE_CRM_USER_GENERAL_ERROR, ex);
|
|
return ret;
|
|
}
|
|
|
|
try
|
|
{
|
|
DataProvider.CreateCRMUser(user.AccountId, crmId, businessUnitId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CANNOT_CREATE_CRM_USER_IN_DATABASE, ex);
|
|
return ret;
|
|
}
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
CompleteTask(ret, CrmErrorCodes.CREATE_CRM_USER_GENERAL_ERROR, ex);
|
|
return ret;
|
|
}
|
|
CompleteTask();
|
|
return ret;
|
|
}
|
|
|
|
public static CRMBusinessUnitsResult GetCRMBusinessUnits(int itemId, int packageId)
|
|
{
|
|
CRMBusinessUnitsResult res = StartTask<CRMBusinessUnitsResult>("CRM", "GET_CRM_BUSINESS_UNITS");
|
|
try
|
|
{
|
|
int serviceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.HostedCRM);
|
|
if (serviceId == 0)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CRM_IS_NOT_SELECTED_IN_HOSTING_PLAN, null, "CRM is not selected in hosting plan.");
|
|
return res;
|
|
}
|
|
|
|
Organization org;
|
|
try
|
|
{
|
|
org = OrganizationController.GetOrganization(itemId);
|
|
if (org.CrmOrganizationId == Guid.Empty)
|
|
throw new ApplicationException("Current organization is not CRM organization.");
|
|
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CANNOT_GET_CRM_ORGANIZATION, ex);
|
|
return res;
|
|
}
|
|
|
|
CRM crm = new CRM();
|
|
ServiceProviderProxy.Init(crm, serviceId);
|
|
CRMBusinessUnitsResult providerRes = crm.GetOrganizationBusinessUnits(org.CrmOrganizationId, org.OrganizationId);
|
|
res.ErrorCodes.AddRange(providerRes.ErrorCodes);
|
|
if (!providerRes.IsSuccess)
|
|
{
|
|
CompleteTask(res);
|
|
return res;
|
|
}
|
|
res.Value = providerRes.Value;
|
|
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CANNOT_GET_BUSINESS_UNITS_GENERAL_ERROR, ex);
|
|
return res;
|
|
}
|
|
|
|
CompleteTask();
|
|
return res;
|
|
}
|
|
|
|
public static CrmRolesResult GetCRMRoles(int itemId, int accountId, int packageId)
|
|
{
|
|
CrmRolesResult res = StartTask<CrmRolesResult>("CRM", "GET_CRM_ROLES");
|
|
|
|
try
|
|
{
|
|
int serviceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.HostedCRM);
|
|
if (serviceId == 0)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CRM_IS_NOT_SELECTED_IN_HOSTING_PLAN, null, "CRM is not selected in hosting plan.");
|
|
return res;
|
|
}
|
|
|
|
CRM crm = new CRM();
|
|
ServiceProviderProxy.Init(crm, serviceId);
|
|
|
|
Organization org = OrganizationController.GetOrganization(itemId);
|
|
|
|
CrmUserResult crmUserResult = GetCrmUser(itemId, accountId);
|
|
res.ErrorCodes.AddRange(crmUserResult.ErrorCodes);
|
|
if (!crmUserResult.IsSuccess)
|
|
{
|
|
CompleteTask(res);
|
|
return res;
|
|
}
|
|
|
|
CrmUser crmUser = crmUserResult.Value;
|
|
CrmRolesResult crmRoles = crm.GetAllCrmRoles(org.OrganizationId, crmUser.BusinessUnitId);
|
|
res.ErrorCodes.AddRange(crmRoles.ErrorCodes);
|
|
if (!crmRoles.IsSuccess)
|
|
{
|
|
CompleteTask(res);
|
|
return res;
|
|
}
|
|
Guid userId = crmUser.CRMUserId;
|
|
CrmRolesResult crmUserRoles = crm.GetCrmUserRoles(org.OrganizationId, userId);
|
|
|
|
res.ErrorCodes.AddRange(crmUserRoles.ErrorCodes);
|
|
if (!crmUserRoles.IsSuccess)
|
|
{
|
|
CompleteTask(res);
|
|
return res;
|
|
}
|
|
|
|
foreach (CrmRole role in crmUserRoles.Value)
|
|
{
|
|
CrmRole retRole = crmRoles.Value.Find(delegate(CrmRole currentRole)
|
|
{
|
|
return currentRole.RoleId == role.RoleId;
|
|
});
|
|
if (retRole != null)
|
|
retRole.IsCurrentUserRole = true;
|
|
}
|
|
|
|
res.Value = crmRoles.Value;
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CANNOT_GET_CRM_ROLES_GENERAL_ERROR, ex);
|
|
return res;
|
|
}
|
|
|
|
CompleteTask();
|
|
return res;
|
|
}
|
|
|
|
|
|
public static Guid GetCrmUserId(int accountId)
|
|
{
|
|
IDataReader reader = DataProvider.GetCrmUser(accountId);
|
|
CrmUser user = ObjectUtils.FillObjectFromDataReader<CrmUser>(reader);
|
|
return user == null ? Guid.Empty :user.CRMUserId;
|
|
|
|
}
|
|
|
|
public static CrmUserResult GetCrmUser(int itemId, int accountId)
|
|
{
|
|
CrmUserResult res = StartTask<CrmUserResult>("CRM", "GET_CRM_USER");
|
|
|
|
try
|
|
{
|
|
Guid crmUserId = GetCrmUserId(accountId);
|
|
|
|
Organization org;
|
|
|
|
try
|
|
{
|
|
org = OrganizationController.GetOrganization(itemId);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
CompleteTask(res, ErrorCodes.CANNOT_GET_ORGANIZATION_BY_ITEM_ID, ex);
|
|
return res;
|
|
}
|
|
|
|
|
|
int serviceId = PackageController.GetPackageServiceId(org.PackageId, ResourceGroups.HostedCRM);
|
|
if (serviceId == 0)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CRM_IS_NOT_SELECTED_IN_HOSTING_PLAN, null,
|
|
"CRM is not selected in hosting plan.");
|
|
return res;
|
|
}
|
|
|
|
try
|
|
{
|
|
CRM crm = new CRM();
|
|
ServiceProviderProxy.Init(crm, serviceId);
|
|
CrmUserResult user = crm.GetCrmUserById(crmUserId, org.OrganizationId);
|
|
res.ErrorCodes.AddRange(user.ErrorCodes);
|
|
if (!user.IsSuccess)
|
|
{
|
|
CompleteTask(res);
|
|
return res;
|
|
}
|
|
res.Value = user.Value;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CANONT_GET_CRM_USER_BY_ID, ex);
|
|
return res;
|
|
}
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CANONT_GET_CRM_USER_GENERAL_ERROR, ex);
|
|
return res;
|
|
}
|
|
CompleteTask();
|
|
return res;
|
|
}
|
|
|
|
|
|
|
|
public static ResultObject SetUserRoles(int itemId, int accountId, int packageId, Guid[] roles)
|
|
{
|
|
CrmRolesResult res = StartTask<CrmRolesResult>("CRM", "GET_CRM_ROLES");
|
|
|
|
try
|
|
{
|
|
|
|
int serviceId = PackageController.GetPackageServiceId(packageId, ResourceGroups.HostedCRM);
|
|
if (serviceId == 0)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CRM_IS_NOT_SELECTED_IN_HOSTING_PLAN, null,
|
|
"CRM is not selected in hosting plan.");
|
|
return res;
|
|
}
|
|
|
|
CRM crm = new CRM();
|
|
ServiceProviderProxy.Init(crm, serviceId);
|
|
|
|
Organization org;
|
|
|
|
try
|
|
{
|
|
org = OrganizationController.GetOrganization(itemId);
|
|
if (org == null)
|
|
throw new ApplicationException("Org is null.");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
CompleteTask(res, ErrorCodes.CANNOT_GET_ORGANIZATION_BY_ITEM_ID, ex);
|
|
return res;
|
|
}
|
|
|
|
Guid crmUserId = GetCrmUserId(accountId);
|
|
|
|
ResultObject rolesRes = crm.SetUserRoles(org.OrganizationId, crmUserId, roles);
|
|
res.ErrorCodes.AddRange(rolesRes.ErrorCodes);
|
|
if (!rolesRes.IsSuccess)
|
|
{
|
|
CompleteTask(res);
|
|
return res;
|
|
}
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CANNOT_SET_CRM_USER_ROLES_GENERAL_ERROR, ex);
|
|
return res;
|
|
}
|
|
CompleteTask();
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
public static ResultObject ChangeUserState(int itemId, int accountId, bool disable)
|
|
{
|
|
CrmRolesResult res = StartTask<CrmRolesResult>("CRM", "CHANGER_USER_STATE");
|
|
|
|
Organization org;
|
|
try
|
|
{
|
|
try
|
|
{
|
|
org = OrganizationController.GetOrganization(itemId);
|
|
if (org == null)
|
|
throw new ApplicationException("Org is null.");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
CompleteTask(res, ErrorCodes.CANNOT_GET_ORGANIZATION_BY_ITEM_ID, ex);
|
|
return res;
|
|
}
|
|
|
|
int serviceId = PackageController.GetPackageServiceId(org.PackageId, ResourceGroups.HostedCRM);
|
|
if (serviceId == 0)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CRM_IS_NOT_SELECTED_IN_HOSTING_PLAN, null,
|
|
"CRM is not selected in hosting plan.");
|
|
return res;
|
|
}
|
|
|
|
CRM crm = new CRM();
|
|
ServiceProviderProxy.Init(crm, serviceId);
|
|
|
|
Guid crmUserId = GetCrmUserId(accountId);
|
|
|
|
ResultObject changeStateRes = crm.ChangeUserState(disable, org.OrganizationId, crmUserId);
|
|
|
|
if (!changeStateRes.IsSuccess)
|
|
res.IsSuccess = false;
|
|
|
|
res.ErrorCodes.AddRange(changeStateRes.ErrorCodes);
|
|
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CANNOT_CHANGE_USER_STATE_GENERAL_ERROR, ex);
|
|
return res;
|
|
}
|
|
|
|
CompleteTask();
|
|
return res;
|
|
}
|
|
|
|
|
|
private static BoolResult CheckQuota(int packageId, int itemId)
|
|
{
|
|
BoolResult res = StartTask<BoolResult>("CRM", "CHECK_QUOTA");
|
|
try
|
|
{
|
|
PackageContext cntx = PackageController.GetPackageContext(packageId);
|
|
|
|
IntResult tmp = GetCRMUsersCount(itemId, string.Empty, string.Empty);
|
|
res.ErrorCodes.AddRange(tmp.ErrorCodes);
|
|
if (!tmp.IsSuccess)
|
|
{
|
|
CompleteTask(res);
|
|
return res;
|
|
}
|
|
|
|
|
|
int allocatedCrmUsers = cntx.Quotas[Quotas.CRM_USERS].QuotaAllocatedValue;
|
|
res.Value = allocatedCrmUsers == -1 || allocatedCrmUsers >= tmp.Value;
|
|
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
CompleteTask(res, CrmErrorCodes.CHECK_QUOTA, ex);
|
|
return res;
|
|
}
|
|
|
|
CompleteTask();
|
|
return res;
|
|
}
|
|
|
|
}
|
|
}
|