public OrganizationGeneralSettings GetOrganizationGeneralSettings(int itemId)
{
return(OrganizationController.GetOrganizationGeneralSettings(itemId));
}
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 SfBUserResult CreateSfBUser(int itemId, int accountId, int sfbUserPlanId)
{
SfBUserResult res = TaskManager.StartResultTask <SfBUserResult>("SFB", "CREATE_SFB_USER");
int accountCheck = SecurityContext.CheckAccount(DemandAccount.NotDemo | DemandAccount.IsActive);
if (accountCheck < 0)
{
TaskManager.CompleteResultTask(res, SfBErrorCodes.NOT_AUTHORIZED);
return(res);
}
SfBUser retSfBUser = new SfBUser();
bool isSfBUser;
isSfBUser = DataProvider.CheckSfBUserExists(accountId);
if (isSfBUser)
{
TaskManager.CompleteResultTask(res, SfBErrorCodes.USER_IS_ALREADY_SFB_USER);
return(res);
}
OrganizationUser user;
user = OrganizationController.GetAccount(itemId, accountId);
if (user == null)
{
TaskManager.CompleteResultTask(res, ErrorCodes.CANNOT_GET_ACCOUNT);
return(res);
}
user = OrganizationController.GetUserGeneralSettings(itemId, accountId);
if (string.IsNullOrEmpty(user.FirstName))
{
TaskManager.CompleteResultTask(res, SfBErrorCodes.USER_FIRST_NAME_IS_NOT_SPECIFIED);
return(res);
}
if (string.IsNullOrEmpty(user.LastName))
{
TaskManager.CompleteResultTask(res, SfBErrorCodes.USER_LAST_NAME_IS_NOT_SPECIFIED);
return(res);
}
bool quota = CheckQuota(itemId);
if (!quota)
{
TaskManager.CompleteResultTask(res, SfBErrorCodes.USER_QUOTA_HAS_BEEN_REACHED);
return(res);
}
SfBServer sfb;
try
{
bool bReloadConfiguration = false;
Organization org = (Organization)PackageController.GetPackageItem(itemId);
if (org == null)
{
throw new ApplicationException(
string.Format("Organization is null. ItemId={0}", itemId));
}
int sfbServiceId = GetSfBServiceID(org.PackageId);
sfb = GetSfBServer(sfbServiceId, org.ServiceId);
if (string.IsNullOrEmpty(org.SfBTenantId))
{
PackageContext cntx = PackageController.GetPackageContext(org.PackageId);
org.SfBTenantId = sfb.CreateOrganization(org.OrganizationId,
org.DefaultDomain,
Convert.ToBoolean(cntx.Quotas[Quotas.SFB_CONFERENCING].QuotaAllocatedValue),
Convert.ToBoolean(cntx.Quotas[Quotas.SFB_ALLOWVIDEO].QuotaAllocatedValue),
Convert.ToInt32(cntx.Quotas[Quotas.SFB_MAXPARTICIPANTS].QuotaAllocatedValue),
Convert.ToBoolean(cntx.Quotas[Quotas.SFB_FEDERATION].QuotaAllocatedValue),
Convert.ToBoolean(cntx.Quotas[Quotas.SFB_ENTERPRISEVOICE].QuotaAllocatedValue));
if (string.IsNullOrEmpty(org.SfBTenantId))
{
TaskManager.CompleteResultTask(res, SfBErrorCodes.CANNOT_ENABLE_ORG);
return(res);
}
else
{
DomainInfo domain = ServerController.GetDomain(org.DefaultDomain);
//Add the service records
if (domain != null)
{
if (domain.ZoneItemId != 0)
{
ServerController.AddServiceDNSRecords(org.PackageId, ResourceGroups.SfB, domain, "");
}
}
PackageController.UpdatePackageItem(org);
bReloadConfiguration = true;
}
}
if (sfb.GetOrganizationTenantId(org.OrganizationId) == string.Empty)
{
PackageContext cntx = PackageController.GetPackageContext(org.PackageId);
org.SfBTenantId = sfb.CreateOrganization(org.OrganizationId,
org.DefaultDomain,
Convert.ToBoolean(cntx.Quotas[Quotas.SFB_CONFERENCING].QuotaAllocatedValue),
Convert.ToBoolean(cntx.Quotas[Quotas.SFB_ALLOWVIDEO].QuotaAllocatedValue),
Convert.ToInt32(cntx.Quotas[Quotas.SFB_MAXPARTICIPANTS].QuotaAllocatedValue),
Convert.ToBoolean(cntx.Quotas[Quotas.SFB_FEDERATION].QuotaAllocatedValue),
Convert.ToBoolean(cntx.Quotas[Quotas.SFB_ENTERPRISEVOICE].QuotaAllocatedValue));
if (string.IsNullOrEmpty(org.SfBTenantId))
{
TaskManager.CompleteResultTask(res, SfBErrorCodes.CANNOT_ENABLE_ORG);
return(res);
}
else
{
PackageController.UpdatePackageItem(org);
bReloadConfiguration = true;
}
}
SfBUserPlan plan = GetSfBUserPlan(itemId, sfbUserPlanId);
if (!sfb.CreateUser(org.OrganizationId, user.UserPrincipalName, plan))
{
TaskManager.CompleteResultTask(res, SfBErrorCodes.CANNOT_ADD_SFB_USER);
return(res);
}
if (bReloadConfiguration)
{
SfBControllerAsync userWorker = new SfBControllerAsync();
userWorker.SfBServiceId = sfbServiceId;
userWorker.OrganizationServiceId = org.ServiceId;
userWorker.Enable_CsComputerAsync();
}
}
catch (Exception ex)
{
TaskManager.CompleteResultTask(res, SfBErrorCodes.CANNOT_ADD_SFB_USER, ex);
return(res);
}
try
{
DataProvider.AddSfBUser(accountId, sfbUserPlanId, user.UserPrincipalName);
}
catch (Exception ex)
{
TaskManager.CompleteResultTask(res, SfBErrorCodes.CANNOT_ADD_SFB_USER_TO_DATABASE, ex);
return(res);
}
res.IsSuccess = true;
TaskManager.CompleteResultTask();
return(res);
}
public Organization GetOrganization(int itemId)
{
return(OrganizationController.GetOrganization(itemId));
}
private static void CreateSut()
{
_mediator = new Mock <IMediator>();
_sut = new OrganizationController(_mediator.Object);
}
public string GetOrganizationUserSummuryLetter(int itemId, int accountId, bool pmm, bool emailMode, bool signup)
{
return(OrganizationController.GetOrganizationUserSummuryLetter(itemId, accountId, pmm, emailMode, signup));
}
public int DeleteOrganization(int itemId)
{
return(OrganizationController.DeleteOrganization(itemId));
}
public int DeleteOrganizationDomain(int itemId, int domainId)
{
return(OrganizationController.DeleteOrganizationDomain(itemId, domainId));
}
public int SetOrganizationDefaultDomain(int itemId, int domainId)
{
return(OrganizationController.SetOrganizationDefaultDomain(itemId, domainId));
}
public int AddOrganizationDomain(int itemId, string domainName)
{
return(OrganizationController.AddOrganizationDomain(itemId, domainName));
}
public List <OrganizationDomainName> GetOrganizationDomains(int itemId)
{
return(OrganizationController.GetOrganizationDomains(itemId));
}
public void ReturnViewWithCorrectModel_WhenUsernameMatch()
{
//Arrange
var username = "******";
var viewEvent = new EventViewModel();
var resultModel = new EventsListViewModel();
resultModel.OngoingEvents = new List <EventViewModel>()
{
viewEvent
};
resultModel.UpCommingEvents = new List <EventViewModel>()
{
viewEvent
};
resultModel.PassedEvents = new List <EventViewModel>()
{
viewEvent
};
var mockedOrganizationService = new Mock <IOrganizationService>();
mockedOrganizationService.Setup(x => x.GetCurrentEvents(username))
.Returns(new List <SofiaDayAndNight.Data.Models.Event>()
{
new SofiaDayAndNight.Data.Models.Event()
});
mockedOrganizationService.Setup(x => x.GetPassedEvents(username))
.Returns(new List <SofiaDayAndNight.Data.Models.Event>()
{
new SofiaDayAndNight.Data.Models.Event()
});
mockedOrganizationService.Setup(x => x.GetUpcomingEvents(username))
.Returns(new List <SofiaDayAndNight.Data.Models.Event>()
{
new SofiaDayAndNight.Data.Models.Event()
});
var mockedMapper = new Mock <IMapper>();
mockedMapper.Setup(x => x.Map <EventViewModel>(
It.IsAny <SofiaDayAndNight.Data.Models.Event>()))
.Returns(viewEvent);
var mockedPhotoHelper = new Mock <IPhotoHelper>();
var mockedUserProvider = new Mock <IUserProvider>();
var controller = new OrganizationController(
mockedOrganizationService.Object,
mockedMapper.Object,
mockedPhotoHelper.Object,
mockedUserProvider.Object);
//Act & Assert
controller
.WithCallTo(x => x.EventsList(username))
.ShouldRenderPartialView("_EventsListPartial")
.WithModel <EventsListViewModel>(model =>
{
Assert.AreEqual(1, model.UpCommingEvents.Count());
Assert.AreEqual(1, model.PassedEvents.Count());
Assert.AreEqual(1, model.OngoingEvents.Count());
Assert.AreEqual(viewEvent, model.UpCommingEvents.First());
Assert.AreEqual(viewEvent, model.PassedEvents.First());
Assert.AreEqual(viewEvent, model.OngoingEvents.First());
});
}
public SystemSettings GetWebDavSystemSettings()
{
return(OrganizationController.GetWebDavSystemSettings());
}
public void UpdateOrganizationPasswordSettings(int itemId, OrganizationPasswordSettings settings)
{
OrganizationController.UpdateOrganizationPasswordSettings(itemId, settings);
}
public DataSet GetRawOrganizationsPaged(int packageId, bool recursive,
string filterColumn, string filterValue, string sortColumn, int startRow, int maximumRows)
{
return(OrganizationController.GetRawOrganizationsPaged(packageId, recursive,
filterColumn, filterValue, sortColumn, startRow, maximumRows));
}
public int CreateUser(int itemId, string displayName, string name, string domain, string password, bool sendNotification, string to)
{
string accountName;
return(OrganizationController.CreateUser(itemId, displayName, name, domain, password, true, sendNotification, to, out accountName));
}
public List <Organization> GetOrganizations(int packageId, bool recursive)
{
return(OrganizationController.GetOrganizations(packageId, recursive));
}
public OrganizationUsersPaged GetOrganizationUsersPaged(int itemId, string filterColumn, string filterValue, string sortColumn,
int startRow, int maximumRows)
{
return(OrganizationController.GetOrganizationUsersPaged(itemId, filterColumn, filterValue, sortColumn, startRow, maximumRows));
}
public int SendOrganizationUserSummuryLetter(int itemId, int accountId, bool signup, string to, string cc)
{
return(OrganizationController.SendSummaryLetter(itemId, accountId, signup, to, cc));
}
public OrganizationUser GetUserGeneralSettings(int itemId, int accountId)
{
return(OrganizationController.GetUserGeneralSettings(itemId, accountId));
}
public OrganizationStatistics GetOrganizationStatistics(int itemId)
{
return(OrganizationController.GetOrganizationStatistics(itemId));
}
public List <OrganizationUser> SearchAccounts(int itemId,
string filterColumn, string filterValue, string sortColumn, bool includeMailboxes)
{
return(OrganizationController.SearchAccounts(itemId,
filterColumn, filterValue, sortColumn, includeMailboxes));
}
public static OCSUserResult CreateOCSUser(int itemId, int accountId)
{
OCSUserResult res = TaskManager.StartResultTask <OCSUserResult>("OCS", "CREATE_OCS_USER");
OCSUser retOCSUser = new OCSUser();
bool isOCSUser;
try
{
isOCSUser = DataProvider.CheckOCSUserExists(accountId);
}
catch (Exception ex)
{
TaskManager.CompleteResultTask(res, OCSErrorCodes.CANNOT_CHECK_IF_OCS_USER_EXISTS, ex);
return(res);
}
if (isOCSUser)
{
TaskManager.CompleteResultTask(res, OCSErrorCodes.USER_IS_ALREADY_OCS_USER);
return(res);
}
OrganizationUser user;
try
{
user = OrganizationController.GetAccount(itemId, accountId);
if (user == null)
{
throw new ApplicationException(
string.Format("User is null. ItemId={0}, AccountId={1}", itemId,
accountId));
}
}
catch (Exception ex)
{
TaskManager.CompleteResultTask(res, ErrorCodes.CANNOT_GET_ACCOUNT, ex);
return(res);
}
try
{
user = OrganizationController.GetUserGeneralSettings(itemId, accountId);
if (string.IsNullOrEmpty(user.FirstName))
{
TaskManager.CompleteResultTask(res, OCSErrorCodes.USER_FIRST_NAME_IS_NOT_SPECIFIED);
return(res);
}
if (string.IsNullOrEmpty(user.LastName))
{
TaskManager.CompleteResultTask(res, OCSErrorCodes.USER_LAST_NAME_IS_NOT_SPECIFIED);
return(res);
}
}
catch (Exception ex)
{
TaskManager.CompleteResultTask(res, OCSErrorCodes.CANNOT_GET_USER_GENERAL_SETTINGS, ex);
return(res);
}
try
{
bool quota = CheckQuota(itemId);
if (!quota)
{
TaskManager.CompleteResultTask(res, OCSErrorCodes.USER_QUOTA_HAS_BEEN_REACHED);
return(res);
}
}
catch (Exception ex)
{
TaskManager.CompleteResultTask(res, OCSErrorCodes.CANNOT_CHECK_QUOTA, ex);
return(res);
}
OCSServer ocs;
try
{
ocs = GetOCSProxy(itemId);
}
catch (Exception ex)
{
TaskManager.CompleteResultTask(res, OCSErrorCodes.CANNOT_GET_OCS_PROXY, ex);
return(res);
}
string instanceId;
try
{
CreateOCSDomains(itemId);
instanceId = ocs.CreateUser(user.PrimaryEmailAddress, user.DistinguishedName);
retOCSUser.InstanceId = instanceId;
}
catch (Exception ex)
{
TaskManager.CompleteResultTask(res, OCSErrorCodes.CANNOT_ADD_OCS_USER, ex);
return(res);
}
try
{
SetUserGeneralSettingsByDefault(itemId, instanceId, ocs);
}
catch (Exception ex)
{
TaskManager.CompleteResultTask(res, OCSErrorCodes.CANNOT_SET_DEFAULT_SETTINGS, ex);
return(res);
}
try
{
DataProvider.AddOCSUser(accountId, instanceId);
}
catch (Exception ex)
{
TaskManager.CompleteResultTask(res, OCSErrorCodes.CANNOT_ADD_OCS_USER_TO_DATABASE, ex);
return(res);
}
res.Value = retOCSUser;
TaskManager.CompleteResultTask();
return(res);
}
public int DeleteUser(int itemId, int accountId)
{
return(OrganizationController.DeleteUser(itemId, accountId));
}
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.AccountName, 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 PasswordPolicyResult GetPasswordPolicy(int itemId)
{
return(OrganizationController.GetPasswordPolicy(itemId));
}
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 int CreateOrganization(int packageId, string organizationID, string organizationName)
{
return(OrganizationController.CreateOrganization(packageId, organizationID, organizationName));
}
public static SfBUserResult SetSfBUserGeneralSettings(int itemId, int accountId, string sipAddress, string lineUri)
{
SfBUserResult res = TaskManager.StartResultTask <SfBUserResult>("SFB", "SET_SFB_USER_GENERAL_SETTINGS");
string PIN = "";
string[] uriAndPin = ("" + lineUri).Split(':');
if (uriAndPin.Length > 0)
{
lineUri = uriAndPin[0];
}
if (uriAndPin.Length > 1)
{
PIN = uriAndPin[1];
}
SfBUser user = null;
try
{
Organization org = (Organization)PackageController.GetPackageItem(itemId);
if (org == null)
{
throw new ApplicationException(
string.Format("Organization is null. ItemId={0}", itemId));
}
int sfbServiceId = GetSfBServiceID(org.PackageId);
SfBServer sfb = GetSfBServer(sfbServiceId, org.ServiceId);
OrganizationUser usr;
usr = OrganizationController.GetAccount(itemId, accountId);
if (usr != null)
{
user = sfb.GetSfBUserGeneralSettings(org.OrganizationId, usr.UserPrincipalName);
}
if (user != null)
{
SfBUserPlan plan = ObjectUtils.FillObjectFromDataReader <SfBUserPlan>(DataProvider.GetSfBUserPlanByAccountId(accountId));
if (plan != null)
{
user.SfBUserPlanId = plan.SfBUserPlanId;
user.SfBUserPlanName = plan.SfBUserPlanName;
}
if (!string.IsNullOrEmpty(sipAddress))
{
if (user.SipAddress != sipAddress)
{
if (sipAddress != usr.UserPrincipalName)
{
if (DataProvider.SfBUserExists(accountId, sipAddress))
{
TaskManager.CompleteResultTask(res, SfBErrorCodes.ADDRESS_ALREADY_USED);
return(res);
}
}
user.SipAddress = sipAddress;
}
}
user.LineUri = lineUri;
user.PIN = PIN;
sfb.SetSfBUserGeneralSettings(org.OrganizationId, usr.UserPrincipalName, user);
DataProvider.UpdateSfBUser(accountId, sipAddress);
}
}
catch (Exception ex)
{
TaskManager.CompleteResultTask(res, SfBErrorCodes.FAILED_SET_SETTINGS, ex);
return(res);
}
res.IsSuccess = true;
TaskManager.CompleteResultTask();
return(res);
}
public void UpdateOrganizationGeneralSettings(int itemId, OrganizationGeneralSettings settings)
{
OrganizationController.UpdateOrganizationGeneralSettings(itemId, settings);
}
