pavelbannov
68483bc979
# Conflicts: # common/ASC.FederatedLogin/LoginProviders/BoxLoginProvider.cs # common/ASC.FederatedLogin/LoginProviders/DocuSignLoginProvider.cs # common/ASC.FederatedLogin/LoginProviders/DropboxLoginProvider.cs # common/ASC.FederatedLogin/LoginProviders/GoogleLoginProvider.cs # common/ASC.FederatedLogin/LoginProviders/OneDriveLoginProvider.cs # web/ASC.Web.Api/Controllers/PortalController.cs # web/ASC.Web.Api/Startup.cs
2770 lines
108 KiB
C#
2770 lines
108 KiB
C#
/*
|
|
*
|
|
* (c) Copyright Ascensio System Limited 2010-2018
|
|
*
|
|
* This program is freeware. You can redistribute it and/or modify it under the terms of the GNU
|
|
* General Public License (GPL) version 3 as published by the Free Software Foundation (https://www.gnu.org/copyleft/gpl.html).
|
|
* In accordance with Section 7(a) of the GNU GPL its Section 15 shall be amended to the effect that
|
|
* Ascensio System SIA expressly excludes the warranty of non-infringement of any third-party rights.
|
|
*
|
|
* THIS PROGRAM IS DISTRIBUTED WITHOUT ANY WARRANTY; WITHOUT EVEN THE IMPLIED WARRANTY OF MERCHANTABILITY OR
|
|
* FITNESS FOR A PARTICULAR PURPOSE. For more details, see GNU GPL at https://www.gnu.org/copyleft/gpl.html
|
|
*
|
|
* You can contact Ascensio System SIA by email at sales@onlyoffice.com
|
|
*
|
|
* The interactive user interfaces in modified source and object code versions of ONLYOFFICE must display
|
|
* Appropriate Legal Notices, as required under Section 5 of the GNU GPL version 3.
|
|
*
|
|
* Pursuant to Section 7 § 3(b) of the GNU GPL you must retain the original ONLYOFFICE logo which contains
|
|
* relevant author attributions when distributing the software. If the display of the logo in its graphic
|
|
* form is not reasonably feasible for technical reasons, you must include the words "Powered by ONLYOFFICE"
|
|
* in every copy of the program you distribute.
|
|
* Pursuant to Section 7 § 3(e) we decline to grant you any rights under trademark law for use of our trademarks.
|
|
*
|
|
*/
|
|
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.Specialized;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Net;
|
|
using System.Net.Mail;
|
|
using System.Security;
|
|
using System.ServiceModel.Security;
|
|
using System.Text.RegularExpressions;
|
|
using System.Web;
|
|
|
|
using ASC.Api.Collections;
|
|
using ASC.Api.Core;
|
|
using ASC.Api.Utils;
|
|
using ASC.Common;
|
|
using ASC.Common.Caching;
|
|
using ASC.Common.Logging;
|
|
using ASC.Common.Utils;
|
|
using ASC.Common.Web;
|
|
using ASC.Core;
|
|
using ASC.Core.Billing;
|
|
using ASC.Core.Common.Configuration;
|
|
using ASC.Core.Common.Notify;
|
|
using ASC.Core.Common.Settings;
|
|
using ASC.Core.Tenants;
|
|
using ASC.Core.Users;
|
|
using ASC.Data.Backup;
|
|
using ASC.Data.Backup.Contracts;
|
|
using ASC.Data.Backup.Service;
|
|
using ASC.Data.Storage;
|
|
using ASC.Data.Storage.Configuration;
|
|
using ASC.Data.Storage.Encryption;
|
|
using ASC.Data.Storage.Migration;
|
|
using ASC.FederatedLogin;
|
|
using ASC.FederatedLogin.LoginProviders;
|
|
using ASC.FederatedLogin.Profile;
|
|
using ASC.IPSecurity;
|
|
using ASC.MessagingSystem;
|
|
using ASC.Security.Cryptography;
|
|
using ASC.Web.Api.Models;
|
|
using ASC.Web.Api.Routing;
|
|
using ASC.Web.Core;
|
|
using ASC.Web.Core.Mobile;
|
|
using ASC.Web.Core.PublicResources;
|
|
using ASC.Web.Core.Sms;
|
|
using ASC.Web.Core.Users;
|
|
using ASC.Web.Core.Utility;
|
|
using ASC.Web.Core.Utility.Settings;
|
|
using ASC.Web.Core.WebZones;
|
|
using ASC.Web.Core.WhiteLabel;
|
|
using ASC.Web.Studio.Core;
|
|
using ASC.Web.Studio.Core.Notify;
|
|
using ASC.Web.Studio.Core.Quota;
|
|
using ASC.Web.Studio.Core.SMS;
|
|
using ASC.Web.Studio.Core.Statistic;
|
|
using ASC.Web.Studio.Core.TFA;
|
|
using ASC.Web.Studio.UserControls.CustomNavigation;
|
|
using ASC.Web.Studio.UserControls.FirstTime;
|
|
using ASC.Web.Studio.UserControls.Management;
|
|
using ASC.Web.Studio.UserControls.Statistics;
|
|
using ASC.Web.Studio.Utility;
|
|
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Hosting;
|
|
using Microsoft.AspNetCore.Http;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using Microsoft.Extensions.Caching.Memory;
|
|
using Microsoft.Extensions.Configuration;
|
|
using Microsoft.Extensions.Options;
|
|
|
|
namespace ASC.Api.Settings
|
|
{
|
|
[Scope]
|
|
[DefaultRoute]
|
|
[ApiController]
|
|
public partial class SettingsController : ControllerBase
|
|
{
|
|
//private const int ONE_THREAD = 1;
|
|
|
|
//private static readonly DistributedTaskQueue quotaTasks = new DistributedTaskQueue("quotaOperations", ONE_THREAD);
|
|
//private static DistributedTaskQueue LDAPTasks { get; } = new DistributedTaskQueue("ldapOperations");
|
|
//private static DistributedTaskQueue SMTPTasks { get; } = new DistributedTaskQueue("smtpOperations");
|
|
public Tenant Tenant { get { return ApiContext.Tenant; } }
|
|
public ApiContext ApiContext { get; }
|
|
private MessageService MessageService { get; }
|
|
private StudioNotifyService StudioNotifyService { get; }
|
|
private IWebHostEnvironment WebHostEnvironment { get; }
|
|
private IServiceProvider ServiceProvider { get; }
|
|
private EmployeeWraperHelper EmployeeWraperHelper { get; }
|
|
private ConsumerFactory ConsumerFactory { get; }
|
|
private SmsProviderManager SmsProviderManager { get; }
|
|
private TimeZoneConverter TimeZoneConverter { get; }
|
|
private CustomNamingPeople CustomNamingPeople { get; }
|
|
private IPSecurity.IPSecurity IpSecurity { get; }
|
|
private IMemoryCache MemoryCache { get; }
|
|
private ProviderManager ProviderManager { get; }
|
|
private MobileDetector MobileDetector { get; }
|
|
private IOptionsSnapshot<AccountLinker> AccountLinker { get; }
|
|
private FirstTimeTenantSettings FirstTimeTenantSettings { get; }
|
|
private UserManager UserManager { get; }
|
|
private TenantManager TenantManager { get; }
|
|
private TenantExtra TenantExtra { get; }
|
|
private TenantStatisticsProvider TenantStatisticsProvider { get; }
|
|
private AuthContext AuthContext { get; }
|
|
private CookiesManager CookiesManager { get; }
|
|
private WebItemSecurity WebItemSecurity { get; }
|
|
private StudioNotifyHelper StudioNotifyHelper { get; }
|
|
private LicenseReader LicenseReader { get; }
|
|
private PermissionContext PermissionContext { get; }
|
|
private SettingsManager SettingsManager { get; }
|
|
private TfaManager TfaManager { get; }
|
|
private WebItemManager WebItemManager { get; }
|
|
private WebItemManagerSecurity WebItemManagerSecurity { get; }
|
|
private TenantInfoSettingsHelper TenantInfoSettingsHelper { get; }
|
|
private TenantWhiteLabelSettingsHelper TenantWhiteLabelSettingsHelper { get; }
|
|
private StorageHelper StorageHelper { get; }
|
|
private TenantLogoManager TenantLogoManager { get; }
|
|
private TenantUtil TenantUtil { get; }
|
|
private CoreBaseSettings CoreBaseSettings { get; }
|
|
private CommonLinkUtility CommonLinkUtility { get; }
|
|
private ColorThemesSettingsHelper ColorThemesSettingsHelper { get; }
|
|
private IConfiguration Configuration { get; }
|
|
private SetupInfo SetupInfo { get; }
|
|
private BuildVersion BuildVersion { get; }
|
|
private DisplayUserSettingsHelper DisplayUserSettingsHelper { get; }
|
|
private StatisticManager StatisticManager { get; }
|
|
private IPRestrictionsService IPRestrictionsService { get; }
|
|
private CoreConfiguration CoreConfiguration { get; }
|
|
private MessageTarget MessageTarget { get; }
|
|
private StudioSmsNotificationSettingsHelper StudioSmsNotificationSettingsHelper { get; }
|
|
private CoreSettings CoreSettings { get; }
|
|
private StorageSettingsHelper StorageSettingsHelper { get; }
|
|
private ServiceClient ServiceClient { get; }
|
|
private StorageFactory StorageFactory { get; }
|
|
private UrlShortener UrlShortener { get; }
|
|
private EncryptionServiceClient EncryptionServiceClient { get; }
|
|
private EncryptionSettingsHelper EncryptionSettingsHelper { get; }
|
|
private BackupServiceNotifier BackupServiceNotifier { get; }
|
|
private ICacheNotify<DeleteSchedule> CacheDeleteSchedule { get; }
|
|
private EncryptionServiceNotifier EncryptionServiceNotifier { get; }
|
|
private PasswordHasher PasswordHasher { get; }
|
|
private ILog Log { get; set; }
|
|
private TelegramHelper TelegramHelper { get; }
|
|
private BackupAjaxHandler BackupAjaxHandler { get; }
|
|
|
|
public SettingsController(
|
|
IOptionsMonitor<ILog> option,
|
|
MessageService messageService,
|
|
StudioNotifyService studioNotifyService,
|
|
ApiContext apiContext,
|
|
UserManager userManager,
|
|
TenantManager tenantManager,
|
|
TenantExtra tenantExtra,
|
|
TenantStatisticsProvider tenantStatisticsProvider,
|
|
AuthContext authContext,
|
|
CookiesManager cookiesManager,
|
|
WebItemSecurity webItemSecurity,
|
|
StudioNotifyHelper studioNotifyHelper,
|
|
LicenseReader licenseReader,
|
|
PermissionContext permissionContext,
|
|
SettingsManager settingsManager,
|
|
TfaManager tfaManager,
|
|
WebItemManager webItemManager,
|
|
WebItemManagerSecurity webItemManagerSecurity,
|
|
TenantInfoSettingsHelper tenantInfoSettingsHelper,
|
|
TenantWhiteLabelSettingsHelper tenantWhiteLabelSettingsHelper,
|
|
StorageHelper storageHelper,
|
|
TenantLogoManager tenantLogoManager,
|
|
TenantUtil tenantUtil,
|
|
CoreBaseSettings coreBaseSettings,
|
|
CommonLinkUtility commonLinkUtility,
|
|
ColorThemesSettingsHelper colorThemesSettingsHelper,
|
|
IConfiguration configuration,
|
|
SetupInfo setupInfo,
|
|
BuildVersion buildVersion,
|
|
DisplayUserSettingsHelper displayUserSettingsHelper,
|
|
StatisticManager statisticManager,
|
|
IPRestrictionsService iPRestrictionsService,
|
|
CoreConfiguration coreConfiguration,
|
|
MessageTarget messageTarget,
|
|
StudioSmsNotificationSettingsHelper studioSmsNotificationSettingsHelper,
|
|
CoreSettings coreSettings,
|
|
StorageSettingsHelper storageSettingsHelper,
|
|
IWebHostEnvironment webHostEnvironment,
|
|
IServiceProvider serviceProvider,
|
|
EmployeeWraperHelper employeeWraperHelper,
|
|
ConsumerFactory consumerFactory,
|
|
SmsProviderManager smsProviderManager,
|
|
TimeZoneConverter timeZoneConverter,
|
|
CustomNamingPeople customNamingPeople,
|
|
IPSecurity.IPSecurity ipSecurity,
|
|
IMemoryCache memoryCache,
|
|
ProviderManager providerManager,
|
|
MobileDetector mobileDetector,
|
|
IOptionsSnapshot<AccountLinker> accountLinker,
|
|
FirstTimeTenantSettings firstTimeTenantSettings,
|
|
ServiceClient serviceClient,
|
|
TelegramHelper telegramHelper,
|
|
StorageFactory storageFactory,
|
|
UrlShortener urlShortener,
|
|
EncryptionServiceClient encryptionServiceClient,
|
|
EncryptionSettingsHelper encryptionSettingsHelper,
|
|
BackupServiceNotifier backupServiceNotifier,
|
|
ICacheNotify<DeleteSchedule> cacheDeleteSchedule,
|
|
EncryptionServiceNotifier encryptionServiceNotifier,
|
|
PasswordHasher passwordHasher,
|
|
BackupAjaxHandler backupAjaxHandler)
|
|
{
|
|
Log = option.Get("ASC.Api");
|
|
WebHostEnvironment = webHostEnvironment;
|
|
ServiceProvider = serviceProvider;
|
|
EmployeeWraperHelper = employeeWraperHelper;
|
|
ConsumerFactory = consumerFactory;
|
|
SmsProviderManager = smsProviderManager;
|
|
TimeZoneConverter = timeZoneConverter;
|
|
CustomNamingPeople = customNamingPeople;
|
|
IpSecurity = ipSecurity;
|
|
MemoryCache = memoryCache;
|
|
ProviderManager = providerManager;
|
|
MobileDetector = mobileDetector;
|
|
AccountLinker = accountLinker;
|
|
FirstTimeTenantSettings = firstTimeTenantSettings;
|
|
MessageService = messageService;
|
|
StudioNotifyService = studioNotifyService;
|
|
ApiContext = apiContext;
|
|
UserManager = userManager;
|
|
TenantManager = tenantManager;
|
|
TenantExtra = tenantExtra;
|
|
TenantStatisticsProvider = tenantStatisticsProvider;
|
|
AuthContext = authContext;
|
|
CookiesManager = cookiesManager;
|
|
WebItemSecurity = webItemSecurity;
|
|
StudioNotifyHelper = studioNotifyHelper;
|
|
LicenseReader = licenseReader;
|
|
PermissionContext = permissionContext;
|
|
SettingsManager = settingsManager;
|
|
TfaManager = tfaManager;
|
|
WebItemManager = webItemManager;
|
|
WebItemManagerSecurity = webItemManagerSecurity;
|
|
TenantInfoSettingsHelper = tenantInfoSettingsHelper;
|
|
TenantWhiteLabelSettingsHelper = tenantWhiteLabelSettingsHelper;
|
|
StorageHelper = storageHelper;
|
|
TenantLogoManager = tenantLogoManager;
|
|
TenantUtil = tenantUtil;
|
|
CoreBaseSettings = coreBaseSettings;
|
|
CommonLinkUtility = commonLinkUtility;
|
|
ColorThemesSettingsHelper = colorThemesSettingsHelper;
|
|
Configuration = configuration;
|
|
SetupInfo = setupInfo;
|
|
BuildVersion = buildVersion;
|
|
DisplayUserSettingsHelper = displayUserSettingsHelper;
|
|
StatisticManager = statisticManager;
|
|
IPRestrictionsService = iPRestrictionsService;
|
|
CoreConfiguration = coreConfiguration;
|
|
MessageTarget = messageTarget;
|
|
StudioSmsNotificationSettingsHelper = studioSmsNotificationSettingsHelper;
|
|
CoreSettings = coreSettings;
|
|
StorageSettingsHelper = storageSettingsHelper;
|
|
ServiceClient = serviceClient;
|
|
EncryptionServiceClient = encryptionServiceClient;
|
|
EncryptionSettingsHelper = encryptionSettingsHelper;
|
|
BackupServiceNotifier = backupServiceNotifier;
|
|
CacheDeleteSchedule = cacheDeleteSchedule;
|
|
EncryptionServiceNotifier = encryptionServiceNotifier;
|
|
PasswordHasher = passwordHasher;
|
|
StorageFactory = storageFactory;
|
|
UrlShortener = urlShortener;
|
|
TelegramHelper = telegramHelper;
|
|
BackupAjaxHandler = backupAjaxHandler;
|
|
}
|
|
|
|
[Read("", Check = false)]
|
|
[AllowAnonymous]
|
|
public SettingsWrapper GetSettings()
|
|
{
|
|
var settings = new SettingsWrapper
|
|
{
|
|
Culture = Tenant.GetCulture().ToString(),
|
|
GreetingSettings = Tenant.Name
|
|
};
|
|
|
|
if (AuthContext.IsAuthenticated)
|
|
{
|
|
settings.TrustedDomains = Tenant.TrustedDomains;
|
|
settings.TrustedDomainsType = Tenant.TrustedDomainsType;
|
|
var timeZone = Tenant.TimeZone;
|
|
settings.Timezone = timeZone;
|
|
settings.UtcOffset = TimeZoneConverter.GetTimeZone(timeZone).GetUtcOffset(DateTime.UtcNow);
|
|
settings.UtcHoursOffset = settings.UtcOffset.TotalHours;
|
|
settings.OwnerId = Tenant.OwnerId;
|
|
settings.NameSchemaId = CustomNamingPeople.Current.Id;
|
|
}
|
|
else
|
|
{
|
|
if (!SettingsManager.Load<WizardSettings>().Completed)
|
|
{
|
|
settings.WizardToken = CommonLinkUtility.GetToken("", ConfirmType.Wizard, userId: Tenant.OwnerId);
|
|
}
|
|
|
|
settings.EnabledJoin =
|
|
(Tenant.TrustedDomainsType == TenantTrustedDomainsType.Custom &&
|
|
Tenant.TrustedDomains.Count > 0) ||
|
|
Tenant.TrustedDomainsType == TenantTrustedDomainsType.All;
|
|
|
|
var studioAdminMessageSettings = SettingsManager.Load<StudioAdminMessageSettings>();
|
|
|
|
settings.EnableAdmMess = studioAdminMessageSettings.Enable || TenantExtra.IsNotPaid();
|
|
|
|
settings.ThirdpartyEnable = SetupInfo.ThirdPartyAuthEnabled && ProviderManager.IsNotEmpty;
|
|
|
|
settings.PasswordHash = PasswordHasher;
|
|
}
|
|
|
|
return settings;
|
|
}
|
|
|
|
[Create("messagesettings")]
|
|
public object EnableAdminMessageSettingsFromBody([FromBody]AdminMessageSettingsModel model)
|
|
{
|
|
return EnableAdminMessageSettings(model);
|
|
}
|
|
|
|
[Create("messagesettings")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public object EnableAdminMessageSettingsFromForm([FromForm] AdminMessageSettingsModel model)
|
|
{
|
|
return EnableAdminMessageSettings(model);
|
|
}
|
|
|
|
private object EnableAdminMessageSettings(AdminMessageSettingsModel model)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
SettingsManager.Save(new StudioAdminMessageSettings { Enable = model.TurnOn });
|
|
|
|
MessageService.Send(MessageAction.AdministratorMessageSettingsUpdated);
|
|
|
|
return Resource.SuccessfullySaveSettingsMessage;
|
|
}
|
|
|
|
[AllowAnonymous]
|
|
[Create("sendadmmail")]
|
|
public object SendAdmMailFromBody([FromBody]AdminMessageSettingsModel model)
|
|
{
|
|
return SendAdmMail(model);
|
|
}
|
|
|
|
[AllowAnonymous]
|
|
[Create("sendadmmail")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public object SendAdmMailFromForm([FromForm] AdminMessageSettingsModel model)
|
|
{
|
|
return SendAdmMail(model);
|
|
}
|
|
|
|
private object SendAdmMail(AdminMessageSettingsModel model)
|
|
{
|
|
var studioAdminMessageSettings = SettingsManager.Load<StudioAdminMessageSettings>();
|
|
var enableAdmMess = studioAdminMessageSettings.Enable || TenantExtra.IsNotPaid();
|
|
|
|
if (!enableAdmMess)
|
|
throw new MethodAccessException("Method not available");
|
|
|
|
if (!model.Email.TestEmailRegex())
|
|
throw new Exception(Resource.ErrorNotCorrectEmail);
|
|
|
|
if (string.IsNullOrEmpty(model.Message))
|
|
throw new Exception(Resource.ErrorEmptyMessage);
|
|
|
|
CheckCache("sendadmmail");
|
|
|
|
StudioNotifyService.SendMsgToAdminFromNotAuthUser(model.Email, model.Message);
|
|
MessageService.Send(MessageAction.ContactAdminMailSent);
|
|
|
|
return Resource.AdminMessageSent;
|
|
}
|
|
|
|
[Create("maildomainsettings")]
|
|
public object SaveMailDomainSettingsFromBody([FromBody] MailDomainSettingsModel model)
|
|
{
|
|
return SaveMailDomainSettings(model);
|
|
}
|
|
|
|
[Create("maildomainsettings")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public object SaveMailDomainSettingsFromForm([FromForm] MailDomainSettingsModel model)
|
|
{
|
|
return SaveMailDomainSettings(model);
|
|
}
|
|
|
|
private object SaveMailDomainSettings(MailDomainSettingsModel model)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
if (model.Type == TenantTrustedDomainsType.Custom)
|
|
{
|
|
Tenant.TrustedDomains.Clear();
|
|
foreach (var d in model.Domains.Select(domain => (domain ?? "").Trim().ToLower()))
|
|
{
|
|
if (!(!string.IsNullOrEmpty(d) && new Regex("^[a-z0-9]([a-z0-9-.]){1,98}[a-z0-9]$").IsMatch(d)))
|
|
return Resource.ErrorNotCorrectTrustedDomain;
|
|
|
|
Tenant.TrustedDomains.Add(d);
|
|
}
|
|
|
|
if (Tenant.TrustedDomains.Count == 0)
|
|
model.Type = TenantTrustedDomainsType.None;
|
|
}
|
|
|
|
Tenant.TrustedDomainsType = model.Type;
|
|
|
|
SettingsManager.Save(new StudioTrustedDomainSettings { InviteUsersAsVisitors = model.InviteUsersAsVisitors });
|
|
|
|
TenantManager.SaveTenant(Tenant);
|
|
|
|
MessageService.Send(MessageAction.TrustedMailDomainSettingsUpdated);
|
|
|
|
return Resource.SuccessfullySaveSettingsMessage;
|
|
}
|
|
|
|
[AllowAnonymous]
|
|
[Create("sendjoininvite")]
|
|
public object SendJoinInviteMailFromBody([FromBody]AdminMessageSettingsModel model)
|
|
{
|
|
return SendJoinInviteMail(model);
|
|
}
|
|
|
|
[AllowAnonymous]
|
|
[Create("sendjoininvite")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public object SendJoinInviteMailFromForm([FromForm] AdminMessageSettingsModel model)
|
|
{
|
|
return SendJoinInviteMail(model);
|
|
}
|
|
|
|
private object SendJoinInviteMail(AdminMessageSettingsModel model)
|
|
{
|
|
try
|
|
{
|
|
var email = model.Email;
|
|
if (!(
|
|
(Tenant.TrustedDomainsType == TenantTrustedDomainsType.Custom &&
|
|
Tenant.TrustedDomains.Count > 0) ||
|
|
Tenant.TrustedDomainsType == TenantTrustedDomainsType.All))
|
|
throw new MethodAccessException("Method not available");
|
|
|
|
if (!email.TestEmailRegex())
|
|
throw new Exception(Resource.ErrorNotCorrectEmail);
|
|
|
|
CheckCache("sendjoininvite");
|
|
|
|
var user = UserManager.GetUserByEmail(email);
|
|
if (!user.ID.Equals(Constants.LostUser.ID))
|
|
throw new Exception(CustomNamingPeople.Substitute<Resource>("ErrorEmailAlreadyExists"));
|
|
|
|
var settings = SettingsManager.Load<IPRestrictionsSettings>();
|
|
|
|
if (settings.Enable && !IpSecurity.Verify())
|
|
throw new Exception(Resource.ErrorAccessRestricted);
|
|
|
|
var trustedDomainSettings = SettingsManager.Load<StudioTrustedDomainSettings>();
|
|
var emplType = trustedDomainSettings.InviteUsersAsVisitors ? EmployeeType.Visitor : EmployeeType.User;
|
|
var enableInviteUsers = TenantStatisticsProvider.GetUsersCount() < TenantExtra.GetTenantQuota().ActiveUsers;
|
|
|
|
if (!enableInviteUsers)
|
|
emplType = EmployeeType.Visitor;
|
|
|
|
switch (Tenant.TrustedDomainsType)
|
|
{
|
|
case TenantTrustedDomainsType.Custom:
|
|
{
|
|
var address = new MailAddress(email);
|
|
if (Tenant.TrustedDomains.Any(d => address.Address.EndsWith("@" + d, StringComparison.InvariantCultureIgnoreCase)))
|
|
{
|
|
StudioNotifyService.SendJoinMsg(email, emplType);
|
|
MessageService.Send(MessageInitiator.System, MessageAction.SentInviteInstructions, email);
|
|
return Resource.FinishInviteJoinEmailMessage;
|
|
}
|
|
|
|
throw new Exception(Resource.ErrorEmailDomainNotAllowed);
|
|
}
|
|
case TenantTrustedDomainsType.All:
|
|
{
|
|
StudioNotifyService.SendJoinMsg(email, emplType);
|
|
MessageService.Send(MessageInitiator.System, MessageAction.SentInviteInstructions, email);
|
|
return Resource.FinishInviteJoinEmailMessage;
|
|
}
|
|
default:
|
|
throw new Exception(Resource.ErrorNotCorrectEmail);
|
|
}
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
return Resource.ErrorNotCorrectEmail;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
return e.Message.HtmlEncode();
|
|
}
|
|
}
|
|
|
|
[Read("customschemas")]
|
|
public List<SchemaModel> PeopleSchemas()
|
|
{
|
|
return CustomNamingPeople
|
|
.GetSchemas()
|
|
.Select(r =>
|
|
{
|
|
var names = CustomNamingPeople.GetPeopleNames(r.Key);
|
|
var schemaItem = new SchemaItemModel
|
|
{
|
|
Id = names.Id,
|
|
UserCaption = names.UserCaption,
|
|
UsersCaption = names.UsersCaption,
|
|
GroupCaption = names.GroupCaption,
|
|
GroupsCaption = names.GroupsCaption,
|
|
UserPostCaption = names.UserPostCaption,
|
|
RegDateCaption = names.RegDateCaption,
|
|
GroupHeadCaption = names.GroupHeadCaption,
|
|
GuestCaption = names.GuestCaption,
|
|
GuestsCaption = names.GuestsCaption,
|
|
};
|
|
|
|
return new SchemaModel
|
|
{
|
|
Id = r.Key,
|
|
Name = r.Value,
|
|
Items = schemaItem
|
|
};
|
|
})
|
|
.ToList();
|
|
}
|
|
|
|
[Read("customschemas/{id}")]
|
|
public SchemaItemModel PeopleSchema(string id)
|
|
{
|
|
var names = CustomNamingPeople.GetPeopleNames(id);
|
|
var schemaItem = new SchemaItemModel
|
|
{
|
|
Id = names.Id,
|
|
UserCaption = names.UserCaption,
|
|
UsersCaption = names.UsersCaption,
|
|
GroupCaption = names.GroupCaption,
|
|
GroupsCaption = names.GroupsCaption,
|
|
UserPostCaption = names.UserPostCaption,
|
|
RegDateCaption = names.RegDateCaption,
|
|
GroupHeadCaption = names.GroupHeadCaption,
|
|
GuestCaption = names.GuestCaption,
|
|
GuestsCaption = names.GuestsCaption,
|
|
};
|
|
return schemaItem;
|
|
}
|
|
|
|
[Read("quota")]
|
|
public QuotaWrapper GetQuotaUsed()
|
|
{
|
|
return new QuotaWrapper(Tenant, CoreBaseSettings, CoreConfiguration, TenantExtra, TenantStatisticsProvider, AuthContext, SettingsManager, WebItemManager);
|
|
}
|
|
|
|
|
|
[AllowAnonymous]
|
|
[Read("authproviders")]
|
|
public ICollection<AccountInfo> GetAuthProviders(bool inviteView, bool settingsView, string clientCallback, string fromOnly)
|
|
{
|
|
ICollection<AccountInfo> infos = new List<AccountInfo>();
|
|
IEnumerable<LoginProfile> linkedAccounts = new List<LoginProfile>();
|
|
|
|
if (AuthContext.IsAuthenticated)
|
|
{
|
|
linkedAccounts = AccountLinker.Get("webstudio").GetLinkedProfiles(AuthContext.CurrentAccount.ID.ToString());
|
|
}
|
|
|
|
fromOnly = string.IsNullOrWhiteSpace(fromOnly) ? string.Empty : fromOnly.ToLower();
|
|
|
|
foreach (var provider in ProviderManager.AuthProviders.Where(provider => string.IsNullOrEmpty(fromOnly) || fromOnly == provider || (provider == "google" && fromOnly == "openid")))
|
|
{
|
|
if (inviteView && provider.ToLower() == "twitter") continue;
|
|
|
|
var loginProvider = ProviderManager.GetLoginProvider(provider);
|
|
if (loginProvider != null && loginProvider.IsEnabled)
|
|
{
|
|
|
|
var url = VirtualPathUtility.ToAbsolute("~/login.ashx") + $"?auth={provider}";
|
|
var mode = (settingsView || inviteView || (!MobileDetector.IsMobile() && !Request.DesktopApp())
|
|
? ("&mode=popup&callback=" + clientCallback)
|
|
: ("&mode=Redirect&returnurl="
|
|
+ HttpUtility.UrlEncode(new Uri(Request.GetUrlRewriter(),
|
|
"Auth.aspx"
|
|
+ (Request.DesktopApp() ? "?desktop=true" : "")
|
|
).ToString())
|
|
));
|
|
|
|
infos.Add(new AccountInfo
|
|
{
|
|
Linked = linkedAccounts.Any(x => x.Provider == provider),
|
|
Provider = provider,
|
|
Url = url + mode
|
|
});
|
|
}
|
|
}
|
|
|
|
return infos;
|
|
}
|
|
|
|
[AllowAnonymous]
|
|
[Read("cultures", Check = false)]
|
|
public IEnumerable<object> GetSupportedCultures()
|
|
{
|
|
return SetupInfo.EnabledCultures.Select(r => r.Name).ToArray();
|
|
}
|
|
|
|
[Authorize(AuthenticationSchemes = "confirm", Roles = "Wizard,Administrators")]
|
|
[Read("timezones", Check = false)]
|
|
public List<TimezonesModel> GetTimeZones()
|
|
{
|
|
ApiContext.AuthByClaim();
|
|
var timeZones = TimeZoneInfo.GetSystemTimeZones().ToList();
|
|
|
|
if (timeZones.All(tz => tz.Id != "UTC"))
|
|
{
|
|
timeZones.Add(TimeZoneInfo.Utc);
|
|
}
|
|
|
|
var listOfTimezones = new List<TimezonesModel>();
|
|
|
|
foreach (var tz in timeZones.OrderBy(z => z.BaseUtcOffset))
|
|
{
|
|
listOfTimezones.Add(new TimezonesModel
|
|
{
|
|
Id = tz.Id,
|
|
DisplayName = TimeZoneConverter.GetTimeZoneDisplayName(tz)
|
|
});
|
|
}
|
|
|
|
return listOfTimezones;
|
|
}
|
|
|
|
[Authorize(AuthenticationSchemes = "confirm", Roles = "Wizard")]
|
|
[Read("machine", Check = false)]
|
|
public object GetMachineName()
|
|
{
|
|
return Dns.GetHostName().ToLowerInvariant();
|
|
}
|
|
|
|
[Read("greetingsettings")]
|
|
public ContentResult GetGreetingSettings()
|
|
{
|
|
return new ContentResult { Content = Tenant.Name };
|
|
}
|
|
|
|
[Create("greetingsettings")]
|
|
public ContentResult SaveGreetingSettingsFromBody([FromBody]GreetingSettingsModel model)
|
|
{
|
|
return SaveGreetingSettings(model);
|
|
}
|
|
|
|
[Create("greetingsettings")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public ContentResult SaveGreetingSettingsFromForm([FromForm]GreetingSettingsModel model)
|
|
{
|
|
return SaveGreetingSettings(model);
|
|
}
|
|
|
|
private ContentResult SaveGreetingSettings(GreetingSettingsModel model)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
Tenant.Name = model.Title;
|
|
TenantManager.SaveTenant(Tenant);
|
|
|
|
MessageService.Send(MessageAction.GreetingSettingsUpdated);
|
|
|
|
return new ContentResult { Content = Resource.SuccessfullySaveGreetingSettingsMessage };
|
|
}
|
|
|
|
[Create("greetingsettings/restore")]
|
|
public ContentResult RestoreGreetingSettings()
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
TenantInfoSettingsHelper.RestoreDefaultTenantName();
|
|
|
|
return new ContentResult
|
|
{
|
|
Content = Tenant.Name
|
|
};
|
|
}
|
|
|
|
//[Read("recalculatequota")]
|
|
//public void RecalculateQuota()
|
|
//{
|
|
// SecurityContext.DemandPermissions(Tenant, SecutiryConstants.EditPortalSettings);
|
|
|
|
// var operations = quotaTasks.GetTasks()
|
|
// .Where(t => t.GetProperty<int>(QuotaSync.TenantIdKey) == Tenant.TenantId);
|
|
|
|
// if (operations.Any(o => o.Status <= DistributedTaskStatus.Running))
|
|
// {
|
|
// throw new InvalidOperationException(Resource.LdapSettingsTooManyOperations);
|
|
// }
|
|
|
|
// var op = new QuotaSync(Tenant.TenantId, ServiceProvider);
|
|
|
|
// quotaTasks.QueueTask(op.RunJob, op.GetDistributedTask());
|
|
//}
|
|
|
|
//[Read("checkrecalculatequota")]
|
|
//public bool CheckRecalculateQuota()
|
|
//{
|
|
// PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
// var task = quotaTasks.GetTasks().FirstOrDefault(t => t.GetProperty<int>(QuotaSync.TenantIdKey) == Tenant.TenantId);
|
|
|
|
// if (task != null && task.Status == DistributedTaskStatus.Completed)
|
|
// {
|
|
// quotaTasks.RemoveTask(task.Id);
|
|
// return false;
|
|
// }
|
|
|
|
// return task != null;
|
|
//}
|
|
|
|
[AllowAnonymous]
|
|
[Read("version/build", false)]
|
|
public BuildVersion GetBuildVersions()
|
|
{
|
|
return BuildVersion.GetCurrentBuildVersion();
|
|
}
|
|
|
|
[Read("version")]
|
|
public TenantVersionWrapper GetVersions()
|
|
{
|
|
return new TenantVersionWrapper(Tenant.Version, TenantManager.GetTenantVersions());
|
|
}
|
|
|
|
[Update("version")]
|
|
public TenantVersionWrapper SetVersionFromBody([FromBody]SettingsModel model)
|
|
{
|
|
return SetVersion(model);
|
|
}
|
|
|
|
[Update("version")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public TenantVersionWrapper SetVersionFromForm([FromForm] SettingsModel model)
|
|
{
|
|
return SetVersion(model);
|
|
}
|
|
|
|
private TenantVersionWrapper SetVersion(SettingsModel model)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
TenantManager.GetTenantVersions().FirstOrDefault(r => r.Id == model.VersionId).NotFoundIfNull();
|
|
TenantManager.SetTenantVersion(Tenant, model.VersionId);
|
|
|
|
return GetVersions();
|
|
}
|
|
|
|
[Read("security")]
|
|
public IEnumerable<SecurityWrapper> GetWebItemSecurityInfo(IEnumerable<string> ids)
|
|
{
|
|
if (ids == null || !ids.Any())
|
|
{
|
|
ids = WebItemManager.GetItemsAll().Select(i => i.ID.ToString());
|
|
}
|
|
|
|
var subItemList = WebItemManager.GetItemsAll().Where(item => item.IsSubItem()).Select(i => i.ID.ToString());
|
|
|
|
return ids.Select(r => WebItemSecurity.GetSecurityInfo(r))
|
|
.Select(i => new SecurityWrapper
|
|
{
|
|
WebItemId = i.WebItemId,
|
|
Enabled = i.Enabled,
|
|
Users = i.Users.Select(EmployeeWraperHelper.Get),
|
|
Groups = i.Groups.Select(g => new GroupWrapperSummary(g, UserManager)),
|
|
IsSubItem = subItemList.Contains(i.WebItemId),
|
|
}).ToList();
|
|
}
|
|
|
|
[Read("security/{id}")]
|
|
public bool GetWebItemSecurityInfo(Guid id)
|
|
{
|
|
var module = WebItemManager[id];
|
|
|
|
return module != null && !module.IsDisabled(WebItemSecurity, AuthContext);
|
|
}
|
|
|
|
[Read("security/modules")]
|
|
public object GetEnabledModules()
|
|
{
|
|
var EnabledModules = WebItemManagerSecurity.GetItems(WebZoneType.All, ItemAvailableState.Normal)
|
|
.Where(item => !item.IsSubItem() && item.Visible)
|
|
.ToList()
|
|
.Select(item => new
|
|
{
|
|
id = item.ProductClassName.HtmlEncode(),
|
|
title = item.Name.HtmlEncode()
|
|
});
|
|
|
|
return EnabledModules;
|
|
}
|
|
|
|
[Read("security/password", Check = false)]
|
|
[Authorize(AuthenticationSchemes = "confirm", Roles = "Everyone")]
|
|
public object GetPasswordSettings()
|
|
{
|
|
var UserPasswordSettings = SettingsManager.Load<PasswordSettings>();
|
|
|
|
return UserPasswordSettings;
|
|
}
|
|
|
|
[Update("security")]
|
|
public IEnumerable<SecurityWrapper> SetWebItemSecurityFromBody([FromBody]WebItemSecurityModel model)
|
|
{
|
|
return SetWebItemSecurity(model);
|
|
}
|
|
|
|
[Update("security")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public IEnumerable<SecurityWrapper> SetWebItemSecurityFromForm([FromForm] WebItemSecurityModel model)
|
|
{
|
|
return SetWebItemSecurity(model);
|
|
}
|
|
|
|
private IEnumerable<SecurityWrapper> SetWebItemSecurity(WebItemSecurityModel model)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
WebItemSecurity.SetSecurity(model.Id, model.Enabled, model.Subjects?.ToArray());
|
|
var securityInfo = GetWebItemSecurityInfo(new List<string> { model.Id });
|
|
|
|
if (model.Subjects == null) return securityInfo;
|
|
|
|
var productName = GetProductName(new Guid(model.Id));
|
|
|
|
if (!model.Subjects.Any())
|
|
{
|
|
MessageService.Send(MessageAction.ProductAccessOpened, productName);
|
|
}
|
|
else
|
|
{
|
|
foreach (var info in securityInfo)
|
|
{
|
|
if (info.Groups.Any())
|
|
{
|
|
MessageService.Send(MessageAction.GroupsOpenedProductAccess, productName, info.Groups.Select(x => x.Name));
|
|
}
|
|
if (info.Users.Any())
|
|
{
|
|
MessageService.Send(MessageAction.UsersOpenedProductAccess, productName, info.Users.Select(x => HttpUtility.HtmlDecode(x.DisplayName)));
|
|
}
|
|
}
|
|
}
|
|
|
|
return securityInfo;
|
|
}
|
|
|
|
[Update("security/access")]
|
|
public IEnumerable<SecurityWrapper> SetAccessToWebItemsFromBody([FromBody]WebItemSecurityModel model)
|
|
{
|
|
return SetAccessToWebItems(model);
|
|
}
|
|
|
|
[Update("security/access")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public IEnumerable<SecurityWrapper> SetAccessToWebItemsFromForm([FromForm] WebItemSecurityModel model)
|
|
{
|
|
return SetAccessToWebItems(model);
|
|
}
|
|
|
|
private IEnumerable<SecurityWrapper> SetAccessToWebItems(WebItemSecurityModel model)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
var itemList = new ItemDictionary<string, bool>();
|
|
|
|
foreach (var item in model.Items)
|
|
{
|
|
if (!itemList.ContainsKey(item.Key))
|
|
itemList.Add(item.Key, item.Value);
|
|
}
|
|
|
|
var defaultPageSettings = SettingsManager.Load<StudioDefaultPageSettings>();
|
|
|
|
foreach (var item in itemList)
|
|
{
|
|
Guid[] subjects = null;
|
|
var productId = new Guid(item.Key);
|
|
|
|
if (item.Value)
|
|
{
|
|
if (WebItemManager[productId] is IProduct webItem || productId == WebItemManager.MailProductID)
|
|
{
|
|
var productInfo = WebItemSecurity.GetSecurityInfo(item.Key);
|
|
var selectedGroups = productInfo.Groups.Select(group => group.ID).ToList();
|
|
var selectedUsers = productInfo.Users.Select(user => user.ID).ToList();
|
|
selectedUsers.AddRange(selectedGroups);
|
|
if (selectedUsers.Count > 0)
|
|
{
|
|
subjects = selectedUsers.ToArray();
|
|
}
|
|
}
|
|
}
|
|
else if (productId == defaultPageSettings.DefaultProductID)
|
|
{
|
|
SettingsManager.Save((StudioDefaultPageSettings)defaultPageSettings.GetDefault(ServiceProvider));
|
|
}
|
|
|
|
WebItemSecurity.SetSecurity(item.Key, item.Value, subjects);
|
|
}
|
|
|
|
MessageService.Send(MessageAction.ProductsListUpdated);
|
|
|
|
return GetWebItemSecurityInfo(itemList.Keys.ToList());
|
|
}
|
|
|
|
[Read("security/administrator/{productid}")]
|
|
public IEnumerable<EmployeeWraper> GetProductAdministrators(Guid productid)
|
|
{
|
|
return WebItemSecurity.GetProductAdministrators(productid)
|
|
.Select(EmployeeWraperHelper.Get)
|
|
.ToList();
|
|
}
|
|
|
|
[Read("security/administrator")]
|
|
public object IsProductAdministrator(Guid productid, Guid userid)
|
|
{
|
|
var result = WebItemSecurity.IsProductAdministrator(productid, userid);
|
|
return new { ProductId = productid, UserId = userid, Administrator = result };
|
|
}
|
|
|
|
[Update("security/administrator")]
|
|
public object SetProductAdministratorFromBody([FromBody]SecurityModel model)
|
|
{
|
|
return SetProductAdministrator(model);
|
|
}
|
|
|
|
[Update("security/administrator")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public object SetProductAdministratorFromForm([FromForm] SecurityModel model)
|
|
{
|
|
return SetProductAdministrator(model);
|
|
}
|
|
|
|
private object SetProductAdministrator(SecurityModel model)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
WebItemSecurity.SetProductAdministrator(model.ProductId, model.UserId, model.Administrator);
|
|
|
|
var admin = UserManager.GetUsers(model.UserId);
|
|
|
|
if (model.ProductId == Guid.Empty)
|
|
{
|
|
var messageAction = model.Administrator ? MessageAction.AdministratorOpenedFullAccess : MessageAction.AdministratorDeleted;
|
|
MessageService.Send(messageAction, MessageTarget.Create(admin.ID), admin.DisplayUserName(false, DisplayUserSettingsHelper));
|
|
}
|
|
else
|
|
{
|
|
var messageAction = model.Administrator ? MessageAction.ProductAddedAdministrator : MessageAction.ProductDeletedAdministrator;
|
|
MessageService.Send(messageAction, MessageTarget.Create(admin.ID), GetProductName(model.ProductId), admin.DisplayUserName(false, DisplayUserSettingsHelper));
|
|
}
|
|
|
|
return new { model.ProductId, model.UserId, model.Administrator };
|
|
}
|
|
|
|
[Read("logo")]
|
|
public object GetLogo()
|
|
{
|
|
return TenantInfoSettingsHelper.GetAbsoluteCompanyLogoPath(SettingsManager.Load<TenantInfoSettings>());
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Create("whitelabel/save")]
|
|
public bool SaveWhiteLabelSettingsFromBody([FromBody] WhiteLabelModel model, [FromQuery] WhiteLabelQuery query)
|
|
{
|
|
return SaveWhiteLabelSettings(model, query);
|
|
}
|
|
|
|
[Create("whitelabel/save")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public bool SaveWhiteLabelSettingsFromForm([FromForm] WhiteLabelModel model, [FromQuery] WhiteLabelQuery query)
|
|
{
|
|
return SaveWhiteLabelSettings(model, query);
|
|
}
|
|
|
|
private bool SaveWhiteLabelSettings(WhiteLabelModel model, WhiteLabelQuery query)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
if (!TenantLogoManager.WhiteLabelEnabled || !TenantLogoManager.WhiteLabelPaid)
|
|
{
|
|
throw new BillingException(Resource.ErrorNotAllowedOption, "WhiteLabel");
|
|
}
|
|
|
|
if (query.IsDefault)
|
|
{
|
|
DemandRebrandingPermission();
|
|
SaveWhiteLabelSettingsForDefaultTenant(model);
|
|
}
|
|
else
|
|
{
|
|
SaveWhiteLabelSettingsForCurrentTenant(model);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void SaveWhiteLabelSettingsForCurrentTenant(WhiteLabelModel model)
|
|
{
|
|
var settings = SettingsManager.Load<TenantWhiteLabelSettings>();
|
|
|
|
SaveWhiteLabelSettingsForTenant(settings, null, Tenant.TenantId, model);
|
|
}
|
|
|
|
private void SaveWhiteLabelSettingsForDefaultTenant(WhiteLabelModel model)
|
|
{
|
|
var settings = SettingsManager.LoadForDefaultTenant<TenantWhiteLabelSettings>();
|
|
var storage = StorageFactory.GetStorage(string.Empty, "static_partnerdata");
|
|
|
|
SaveWhiteLabelSettingsForTenant(settings, storage, Tenant.DEFAULT_TENANT, model);
|
|
}
|
|
|
|
private void SaveWhiteLabelSettingsForTenant(TenantWhiteLabelSettings settings, IDataStore storage, int tenantId, WhiteLabelModel model)
|
|
{
|
|
if (model.Logo != null)
|
|
{
|
|
var logoDict = new Dictionary<int, string>();
|
|
model.Logo.ToList().ForEach(n => logoDict.Add(Int32.Parse(n.Key), n.Value));
|
|
|
|
TenantWhiteLabelSettingsHelper.SetLogo(settings, logoDict, storage);
|
|
}
|
|
|
|
settings.SetLogoText(model.LogoText);
|
|
TenantWhiteLabelSettingsHelper.Save(settings, tenantId, TenantLogoManager);
|
|
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Create("whitelabel/savefromfiles")]
|
|
public bool SaveWhiteLabelSettingsFromFiles([FromQuery] WhiteLabelQuery query)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
if (!TenantLogoManager.WhiteLabelEnabled || !TenantLogoManager.WhiteLabelPaid)
|
|
{
|
|
throw new BillingException(Resource.ErrorNotAllowedOption, "WhiteLabel");
|
|
}
|
|
|
|
if (HttpContext.Request.Form?.Files == null || !HttpContext.Request.Form.Files.Any())
|
|
{
|
|
throw new InvalidOperationException("No input files");
|
|
}
|
|
|
|
if (query.IsDefault)
|
|
{
|
|
DemandRebrandingPermission();
|
|
SaveWhiteLabelSettingsFromFilesForDefaultTenant();
|
|
}
|
|
else
|
|
{
|
|
SaveWhiteLabelSettingsFromFilesForCurrentTenant();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void SaveWhiteLabelSettingsFromFilesForCurrentTenant()
|
|
{
|
|
var settings = SettingsManager.Load<TenantWhiteLabelSettings>();
|
|
|
|
SaveWhiteLabelSettingsFromFilesForTenant(settings, null, Tenant.TenantId);
|
|
}
|
|
|
|
private void SaveWhiteLabelSettingsFromFilesForDefaultTenant()
|
|
{
|
|
var settings = SettingsManager.LoadForDefaultTenant<TenantWhiteLabelSettings>();
|
|
var storage = StorageFactory.GetStorage(string.Empty, "static_partnerdata");
|
|
|
|
SaveWhiteLabelSettingsFromFilesForTenant(settings, storage, Tenant.DEFAULT_TENANT);
|
|
}
|
|
|
|
private void SaveWhiteLabelSettingsFromFilesForTenant(TenantWhiteLabelSettings settings, IDataStore storage, int tenantId)
|
|
{
|
|
foreach (var f in HttpContext.Request.Form.Files)
|
|
{
|
|
var parts = f.FileName.Split('.');
|
|
var logoType = (WhiteLabelLogoTypeEnum)(Convert.ToInt32(parts[0]));
|
|
var fileExt = parts[1];
|
|
TenantWhiteLabelSettingsHelper.SetLogoFromStream(settings, logoType, fileExt, f.OpenReadStream(), storage);
|
|
}
|
|
|
|
SettingsManager.SaveForTenant(settings, tenantId);
|
|
}
|
|
|
|
|
|
///<visible>false</visible>
|
|
[Read("whitelabel/sizes")]
|
|
public object GetWhiteLabelSizes()
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
if (!TenantLogoManager.WhiteLabelEnabled)
|
|
{
|
|
throw new BillingException(Resource.ErrorNotAllowedOption, "WhiteLabel");
|
|
}
|
|
|
|
return
|
|
new[]
|
|
{
|
|
new {type = (int)WhiteLabelLogoTypeEnum.LightSmall, name = WhiteLabelLogoTypeEnum.LightSmall.ToString(), height = TenantWhiteLabelSettings.logoLightSmallSize.Height, width = TenantWhiteLabelSettings.logoLightSmallSize.Width},
|
|
new {type = (int)WhiteLabelLogoTypeEnum.Dark, name = WhiteLabelLogoTypeEnum.Dark.ToString(), height = TenantWhiteLabelSettings.logoDarkSize.Height, width = TenantWhiteLabelSettings.logoDarkSize.Width},
|
|
new {type = (int)WhiteLabelLogoTypeEnum.Favicon, name = WhiteLabelLogoTypeEnum.Favicon.ToString(), height = TenantWhiteLabelSettings.logoFaviconSize.Height, width = TenantWhiteLabelSettings.logoFaviconSize.Width},
|
|
new {type = (int)WhiteLabelLogoTypeEnum.DocsEditor, name = WhiteLabelLogoTypeEnum.DocsEditor.ToString(), height = TenantWhiteLabelSettings.logoDocsEditorSize.Height, width = TenantWhiteLabelSettings.logoDocsEditorSize.Width}
|
|
};
|
|
}
|
|
|
|
|
|
|
|
///<visible>false</visible>
|
|
[Read("whitelabel/logos")]
|
|
public Dictionary<string, string> GetWhiteLabelLogos([FromQuery] WhiteLabelQuery query)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
if (!TenantLogoManager.WhiteLabelEnabled)
|
|
{
|
|
throw new BillingException(Resource.ErrorNotAllowedOption, "WhiteLabel");
|
|
}
|
|
|
|
Dictionary<string, string> result;
|
|
|
|
if (query.IsDefault)
|
|
{
|
|
DemandRebrandingPermission();
|
|
|
|
result = new Dictionary<string, string>
|
|
{
|
|
{ ((int)WhiteLabelLogoTypeEnum.LightSmall).ToString(), CommonLinkUtility.GetFullAbsolutePath(TenantWhiteLabelSettingsHelper.GetAbsoluteDefaultLogoPath(WhiteLabelLogoTypeEnum.LightSmall, !query.IsRetina)) },
|
|
{ ((int)WhiteLabelLogoTypeEnum.Dark).ToString(), CommonLinkUtility.GetFullAbsolutePath(TenantWhiteLabelSettingsHelper.GetAbsoluteDefaultLogoPath(WhiteLabelLogoTypeEnum.Dark, !query.IsRetina)) },
|
|
{ ((int)WhiteLabelLogoTypeEnum.Favicon).ToString(), CommonLinkUtility.GetFullAbsolutePath(TenantWhiteLabelSettingsHelper.GetAbsoluteDefaultLogoPath(WhiteLabelLogoTypeEnum.Favicon, !query.IsRetina)) },
|
|
{ ((int)WhiteLabelLogoTypeEnum.DocsEditor).ToString(), CommonLinkUtility.GetFullAbsolutePath(TenantWhiteLabelSettingsHelper.GetAbsoluteDefaultLogoPath(WhiteLabelLogoTypeEnum.DocsEditor, !query.IsRetina)) }
|
|
};
|
|
}
|
|
else
|
|
{
|
|
var _tenantWhiteLabelSettings = SettingsManager.Load<TenantWhiteLabelSettings>();
|
|
|
|
result = new Dictionary<string, string>
|
|
{
|
|
{ ((int)WhiteLabelLogoTypeEnum.LightSmall).ToString(), CommonLinkUtility.GetFullAbsolutePath(TenantWhiteLabelSettingsHelper.GetAbsoluteLogoPath(_tenantWhiteLabelSettings, WhiteLabelLogoTypeEnum.LightSmall, !query.IsRetina)) },
|
|
{ ((int)WhiteLabelLogoTypeEnum.Dark).ToString(), CommonLinkUtility.GetFullAbsolutePath(TenantWhiteLabelSettingsHelper.GetAbsoluteLogoPath(_tenantWhiteLabelSettings, WhiteLabelLogoTypeEnum.Dark, !query.IsRetina)) },
|
|
{ ((int)WhiteLabelLogoTypeEnum.Favicon).ToString(), CommonLinkUtility.GetFullAbsolutePath(TenantWhiteLabelSettingsHelper.GetAbsoluteLogoPath(_tenantWhiteLabelSettings, WhiteLabelLogoTypeEnum.Favicon, !query.IsRetina)) },
|
|
{ ((int)WhiteLabelLogoTypeEnum.DocsEditor).ToString(), CommonLinkUtility.GetFullAbsolutePath(TenantWhiteLabelSettingsHelper.GetAbsoluteLogoPath(_tenantWhiteLabelSettings, WhiteLabelLogoTypeEnum.DocsEditor, !query.IsRetina)) }
|
|
};
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Read("whitelabel/logotext")]
|
|
public object GetWhiteLabelLogoText([FromQuery] WhiteLabelQuery query)
|
|
{
|
|
if (!TenantLogoManager.WhiteLabelEnabled)
|
|
{
|
|
throw new BillingException(Resource.ErrorNotAllowedOption, "WhiteLabel");
|
|
}
|
|
|
|
|
|
if (query.IsDefault)
|
|
{
|
|
DemandRebrandingPermission();
|
|
}
|
|
|
|
var settings = query.IsDefault ? SettingsManager.LoadForDefaultTenant<TenantWhiteLabelSettings>() : SettingsManager.Load<TenantWhiteLabelSettings>();
|
|
|
|
return settings.LogoText ?? TenantWhiteLabelSettings.DefaultLogoText;
|
|
}
|
|
|
|
|
|
///<visible>false</visible>
|
|
[Update("whitelabel/restore")]
|
|
public bool RestoreWhiteLabelOptions(WhiteLabelQuery query)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
if (!TenantLogoManager.WhiteLabelEnabled || !TenantLogoManager.WhiteLabelPaid)
|
|
{
|
|
throw new BillingException(Resource.ErrorNotAllowedOption, "WhiteLabel");
|
|
}
|
|
if (query.IsDefault)
|
|
{
|
|
DemandRebrandingPermission();
|
|
RestoreWhiteLabelOptionsForDefaultTenant();
|
|
}
|
|
else
|
|
{
|
|
RestoreWhiteLabelOptionsForCurrentTenant();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void RestoreWhiteLabelOptionsForCurrentTenant()
|
|
{
|
|
var settings = SettingsManager.Load<TenantWhiteLabelSettings>();
|
|
|
|
RestoreWhiteLabelOptionsForTenant(settings, null, Tenant.TenantId);
|
|
|
|
var tenantInfoSettings = SettingsManager.Load<TenantInfoSettings>();
|
|
TenantInfoSettingsHelper.RestoreDefaultLogo(tenantInfoSettings, TenantLogoManager);
|
|
SettingsManager.Save(tenantInfoSettings);
|
|
}
|
|
|
|
private void RestoreWhiteLabelOptionsForDefaultTenant()
|
|
{
|
|
var settings = SettingsManager.LoadForDefaultTenant<TenantWhiteLabelSettings>();
|
|
var storage = StorageFactory.GetStorage(string.Empty, "static_partnerdata");
|
|
|
|
RestoreWhiteLabelOptionsForTenant(settings, storage, Tenant.DEFAULT_TENANT);
|
|
}
|
|
|
|
private void RestoreWhiteLabelOptionsForTenant(TenantWhiteLabelSettings settings, IDataStore storage, int tenantId)
|
|
{
|
|
TenantWhiteLabelSettingsHelper.RestoreDefault(settings, TenantLogoManager, tenantId, storage);
|
|
}
|
|
|
|
|
|
[Read("iprestrictions")]
|
|
public IEnumerable<IPRestriction> GetIpRestrictions()
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
return IPRestrictionsService.Get(Tenant.TenantId);
|
|
}
|
|
|
|
[Update("iprestrictions")]
|
|
public IEnumerable<string> SaveIpRestrictionsFromBody([FromBody]IpRestrictionsModel model)
|
|
{
|
|
return SaveIpRestrictions(model);
|
|
}
|
|
|
|
[Update("iprestrictions")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public IEnumerable<string> SaveIpRestrictionsFromForm([FromForm] IpRestrictionsModel model)
|
|
{
|
|
return SaveIpRestrictions(model);
|
|
}
|
|
|
|
private IEnumerable<string> SaveIpRestrictions(IpRestrictionsModel model)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
return IPRestrictionsService.Save(model.Ips, Tenant.TenantId);
|
|
}
|
|
|
|
[Update("iprestrictions/settings")]
|
|
public IPRestrictionsSettings UpdateIpRestrictionsSettingsFromBody([FromBody]IpRestrictionsModel model)
|
|
{
|
|
return UpdateIpRestrictionsSettings(model);
|
|
}
|
|
|
|
[Update("iprestrictions/settings")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public IPRestrictionsSettings UpdateIpRestrictionsSettingsFromForm([FromForm] IpRestrictionsModel model)
|
|
{
|
|
return UpdateIpRestrictionsSettings(model);
|
|
}
|
|
|
|
private IPRestrictionsSettings UpdateIpRestrictionsSettings(IpRestrictionsModel model)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
var settings = new IPRestrictionsSettings { Enable = model.Enable };
|
|
SettingsManager.Save(settings);
|
|
|
|
return settings;
|
|
}
|
|
|
|
[Update("tips")]
|
|
public TipsSettings UpdateTipsSettingsFromBody([FromBody]SettingsModel model)
|
|
{
|
|
return UpdateTipsSettings(model);
|
|
}
|
|
|
|
[Update("tips")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public TipsSettings UpdateTipsSettingsFromForm([FromForm] SettingsModel model)
|
|
{
|
|
return UpdateTipsSettings(model);
|
|
}
|
|
|
|
private TipsSettings UpdateTipsSettings(SettingsModel model)
|
|
{
|
|
var settings = new TipsSettings { Show = model.Show };
|
|
SettingsManager.SaveForCurrentUser(settings);
|
|
|
|
if (!model.Show && !string.IsNullOrEmpty(SetupInfo.TipsAddress))
|
|
{
|
|
try
|
|
{
|
|
using var client = new WebClient();
|
|
var data = new NameValueCollection
|
|
{
|
|
["userId"] = AuthContext.CurrentAccount.ID.ToString(),
|
|
["tenantId"] = Tenant.TenantId.ToString(CultureInfo.InvariantCulture)
|
|
};
|
|
|
|
client.UploadValues(string.Format("{0}/tips/deletereaded", SetupInfo.TipsAddress), data);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Error(e.Message, e);
|
|
}
|
|
}
|
|
|
|
return settings;
|
|
}
|
|
|
|
[Update("tips/change/subscription")]
|
|
public bool UpdateTipsSubscription()
|
|
{
|
|
return StudioPeriodicNotify.ChangeSubscription(AuthContext.CurrentAccount.ID, StudioNotifyHelper);
|
|
}
|
|
|
|
[Update("wizard/complete", Check = false)]
|
|
[Authorize(AuthenticationSchemes = "confirm", Roles = "Wizard")]
|
|
public WizardSettings CompleteWizardFromBody([FromBody]WizardModel wizardModel)
|
|
{
|
|
return CompleteWizard(wizardModel);
|
|
}
|
|
|
|
[Update("wizard/complete", Check = false)]
|
|
[Authorize(AuthenticationSchemes = "confirm", Roles = "Wizard")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public WizardSettings CompleteWizardFromForm([FromForm] WizardModel wizardModel)
|
|
{
|
|
return CompleteWizard(wizardModel);
|
|
}
|
|
|
|
private WizardSettings CompleteWizard(WizardModel wizardModel)
|
|
{
|
|
ApiContext.AuthByClaim();
|
|
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
return FirstTimeTenantSettings.SaveData(wizardModel);
|
|
}
|
|
|
|
|
|
[Update("tfaapp")]
|
|
public bool TfaSettingsFromBody([FromBody]TfaModel model)
|
|
{
|
|
return TfaSettings(model);
|
|
}
|
|
|
|
[Update("tfaapp")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public bool TfaSettingsFromForm([FromForm] TfaModel model)
|
|
{
|
|
return TfaSettings(model);
|
|
}
|
|
|
|
private bool TfaSettings(TfaModel model)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
var result = false;
|
|
|
|
MessageAction action;
|
|
var settings = SettingsManager.Load<TfaAppAuthSettings>();
|
|
|
|
switch (model.Type)
|
|
{
|
|
case "sms":
|
|
if (!StudioSmsNotificationSettingsHelper.IsVisibleSettings())
|
|
throw new Exception(Resource.SmsNotAvailable);
|
|
|
|
if (!SmsProviderManager.Enabled())
|
|
throw new MethodAccessException();
|
|
|
|
StudioSmsNotificationSettingsHelper.Enable = true;
|
|
action = MessageAction.TwoFactorAuthenticationEnabledBySms;
|
|
|
|
if (settings.EnableSetting)
|
|
{
|
|
settings.EnableSetting = false;
|
|
SettingsManager.Save(settings);
|
|
}
|
|
|
|
result = true;
|
|
|
|
break;
|
|
|
|
case "app":
|
|
if (!TfaAppAuthSettings.IsVisibleSettings)
|
|
{
|
|
throw new Exception(Resource.TfaAppNotAvailable);
|
|
}
|
|
|
|
settings.EnableSetting = true;
|
|
SettingsManager.Save(settings);
|
|
|
|
action = MessageAction.TwoFactorAuthenticationEnabledByTfaApp;
|
|
|
|
if (StudioSmsNotificationSettingsHelper.IsVisibleSettings() && StudioSmsNotificationSettingsHelper.Enable)
|
|
{
|
|
StudioSmsNotificationSettingsHelper.Enable = false;
|
|
}
|
|
|
|
result = true;
|
|
|
|
break;
|
|
|
|
default:
|
|
if (settings.EnableSetting)
|
|
{
|
|
settings.EnableSetting = false;
|
|
SettingsManager.Save(settings);
|
|
}
|
|
|
|
if (StudioSmsNotificationSettingsHelper.IsVisibleSettings() && StudioSmsNotificationSettingsHelper.Enable)
|
|
{
|
|
StudioSmsNotificationSettingsHelper.Enable = false;
|
|
}
|
|
|
|
action = MessageAction.TwoFactorAuthenticationDisabled;
|
|
|
|
break;
|
|
}
|
|
|
|
if (result)
|
|
{
|
|
CookiesManager.ResetTenantCookie();
|
|
}
|
|
|
|
MessageService.Send(action);
|
|
return result;
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Read("tfaappcodes")]
|
|
public IEnumerable<object> TfaAppGetCodes()
|
|
{
|
|
var currentUser = UserManager.GetUsers(AuthContext.CurrentAccount.ID);
|
|
|
|
if (!TfaAppAuthSettings.IsVisibleSettings || !TfaAppUserSettings.EnableForUser(SettingsManager, currentUser.ID))
|
|
throw new Exception(Resource.TfaAppNotAvailable);
|
|
|
|
if (currentUser.IsVisitor(UserManager) || currentUser.IsOutsider(UserManager))
|
|
throw new NotSupportedException("Not available.");
|
|
|
|
return SettingsManager.LoadForCurrentUser<TfaAppUserSettings>().CodesSetting.Select(r => new { r.IsUsed, r.Code }).ToList();
|
|
}
|
|
|
|
[Update("tfaappnewcodes")]
|
|
public IEnumerable<object> TfaAppRequestNewCodes()
|
|
{
|
|
var currentUser = UserManager.GetUsers(AuthContext.CurrentAccount.ID);
|
|
|
|
if (!TfaAppAuthSettings.IsVisibleSettings || !TfaAppUserSettings.EnableForUser(SettingsManager, currentUser.ID))
|
|
throw new Exception(Resource.TfaAppNotAvailable);
|
|
|
|
if (currentUser.IsVisitor(UserManager) || currentUser.IsOutsider(UserManager))
|
|
throw new NotSupportedException("Not available.");
|
|
|
|
var codes = TfaManager.GenerateBackupCodes().Select(r => new { r.IsUsed, r.Code }).ToList();
|
|
MessageService.Send(MessageAction.UserConnectedTfaApp, MessageTarget.Create(currentUser.ID), currentUser.DisplayUserName(false, DisplayUserSettingsHelper));
|
|
return codes;
|
|
}
|
|
|
|
[Update("tfaappnewapp")]
|
|
public object TfaAppNewAppFromBody([FromBody]TfaModel model)
|
|
{
|
|
return TfaAppNewApp(model);
|
|
}
|
|
|
|
[Update("tfaappnewapp")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public object TfaAppNewAppFromForm([FromForm] TfaModel model)
|
|
{
|
|
return TfaAppNewApp(model);
|
|
}
|
|
|
|
private object TfaAppNewApp(TfaModel model)
|
|
{
|
|
var isMe = model.Id.Equals(Guid.Empty);
|
|
var user = UserManager.GetUsers(isMe ? AuthContext.CurrentAccount.ID : model.Id);
|
|
|
|
if (!isMe && !PermissionContext.CheckPermissions(new UserSecurityProvider(user.ID), Constants.Action_EditUser))
|
|
throw new SecurityAccessDeniedException(Resource.ErrorAccessDenied);
|
|
|
|
if (!TfaAppAuthSettings.IsVisibleSettings || !TfaAppUserSettings.EnableForUser(SettingsManager, user.ID))
|
|
throw new Exception(Resource.TfaAppNotAvailable);
|
|
|
|
if (user.IsVisitor(UserManager) || user.IsOutsider(UserManager))
|
|
throw new NotSupportedException("Not available.");
|
|
|
|
TfaAppUserSettings.DisableForUser(ServiceProvider, SettingsManager, user.ID);
|
|
MessageService.Send(MessageAction.UserDisconnectedTfaApp, MessageTarget.Create(user.ID), user.DisplayUserName(false, DisplayUserSettingsHelper));
|
|
|
|
if (isMe)
|
|
{
|
|
return CommonLinkUtility.GetConfirmationUrl(user.Email, ConfirmType.TfaActivation);
|
|
}
|
|
|
|
StudioNotifyService.SendMsgTfaReset(user);
|
|
return string.Empty;
|
|
}
|
|
|
|
|
|
///<visible>false</visible>
|
|
[Update("welcome/close")]
|
|
public void CloseWelcomePopup()
|
|
{
|
|
var currentUser = UserManager.GetUsers(AuthContext.CurrentAccount.ID);
|
|
|
|
var collaboratorPopupSettings = SettingsManager.LoadForCurrentUser<CollaboratorSettings>();
|
|
|
|
if (!(currentUser.IsVisitor(UserManager) && collaboratorPopupSettings.FirstVisit && !currentUser.IsOutsider(UserManager)))
|
|
throw new NotSupportedException("Not available.");
|
|
|
|
collaboratorPopupSettings.FirstVisit = false;
|
|
SettingsManager.SaveForCurrentUser(collaboratorPopupSettings);
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Update("colortheme")]
|
|
public void SaveColorThemeFromBody([FromBody]SettingsModel model)
|
|
{
|
|
SaveColorTheme(model);
|
|
}
|
|
|
|
[Update("colortheme")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public void SaveColorThemeFromForm([FromForm] SettingsModel model)
|
|
{
|
|
SaveColorTheme(model);
|
|
}
|
|
|
|
private void SaveColorTheme(SettingsModel model)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
ColorThemesSettingsHelper.SaveColorTheme(model.Theme);
|
|
MessageService.Send(MessageAction.ColorThemeChanged);
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Update("timeandlanguage")]
|
|
public object TimaAndLanguageFromBody([FromBody]SettingsModel model)
|
|
{
|
|
return TimaAndLanguage(model);
|
|
}
|
|
|
|
[Update("timeandlanguage")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public object TimaAndLanguageFromForm([FromForm] SettingsModel model)
|
|
{
|
|
return TimaAndLanguage(model);
|
|
}
|
|
|
|
private object TimaAndLanguage(SettingsModel model)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
var culture = CultureInfo.GetCultureInfo(model.Lng);
|
|
|
|
var changelng = false;
|
|
if (SetupInfo.EnabledCultures.Find(c => string.Equals(c.Name, culture.Name, StringComparison.InvariantCultureIgnoreCase)) != null)
|
|
{
|
|
if (!string.Equals(Tenant.Language, culture.Name, StringComparison.InvariantCultureIgnoreCase))
|
|
{
|
|
Tenant.Language = culture.Name;
|
|
changelng = true;
|
|
}
|
|
}
|
|
|
|
var oldTimeZone = Tenant.TimeZone;
|
|
var timeZones = TimeZoneInfo.GetSystemTimeZones().ToList();
|
|
if (timeZones.All(tz => tz.Id != "UTC"))
|
|
{
|
|
timeZones.Add(TimeZoneInfo.Utc);
|
|
}
|
|
Tenant.TimeZone = timeZones.FirstOrDefault(tz => tz.Id == model.TimeZoneID)?.Id ?? TimeZoneInfo.Utc.Id;
|
|
|
|
TenantManager.SaveTenant(Tenant);
|
|
|
|
if (!Tenant.TimeZone.Equals(oldTimeZone) || changelng)
|
|
{
|
|
if (!Tenant.TimeZone.Equals(oldTimeZone))
|
|
{
|
|
MessageService.Send(MessageAction.TimeZoneSettingsUpdated);
|
|
}
|
|
if (changelng)
|
|
{
|
|
MessageService.Send(MessageAction.LanguageSettingsUpdated);
|
|
}
|
|
}
|
|
|
|
return Resource.SuccessfullySaveSettingsMessage;
|
|
}
|
|
|
|
[Create("owner")]
|
|
public object SendOwnerChangeInstructionsFromBody([FromBody]SettingsModel model)
|
|
{
|
|
return SendOwnerChangeInstructions(model);
|
|
}
|
|
|
|
[Create("owner")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public object SendOwnerChangeInstructionsFromForm([FromForm] SettingsModel model)
|
|
{
|
|
return SendOwnerChangeInstructions(model);
|
|
}
|
|
|
|
private object SendOwnerChangeInstructions(SettingsModel model)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
var curTenant = TenantManager.GetCurrentTenant();
|
|
var owner = UserManager.GetUsers(curTenant.OwnerId);
|
|
var newOwner = UserManager.GetUsers(model.OwnerId);
|
|
|
|
if (newOwner.IsVisitor(UserManager)) throw new System.Security.SecurityException("Collaborator can not be an owner");
|
|
|
|
if (!owner.ID.Equals(AuthContext.CurrentAccount.ID) || Guid.Empty.Equals(newOwner.ID))
|
|
{
|
|
return new { Status = 0, Message = Resource.ErrorAccessDenied };
|
|
}
|
|
|
|
var confirmLink = CommonLinkUtility.GetConfirmationUrl(owner.Email, ConfirmType.PortalOwnerChange, newOwner.ID, newOwner.ID);
|
|
StudioNotifyService.SendMsgConfirmChangeOwner(owner, newOwner, confirmLink);
|
|
|
|
MessageService.Send(MessageAction.OwnerSentChangeOwnerInstructions, MessageTarget.Create(owner.ID), owner.DisplayUserName(false, DisplayUserSettingsHelper));
|
|
|
|
var emailLink = string.Format("<a href=\"mailto:{0}\">{0}</a>", owner.Email);
|
|
return new { Status = 1, Message = Resource.ChangePortalOwnerMsg.Replace(":email", emailLink) };
|
|
}
|
|
|
|
[Update("owner")]
|
|
[Authorize(AuthenticationSchemes = "confirm", Roles = "PortalOwnerChange")]
|
|
public void OwnerFromBody([FromBody]SettingsModel model)
|
|
{
|
|
Owner(model);
|
|
}
|
|
|
|
[Update("owner")]
|
|
[Authorize(AuthenticationSchemes = "confirm", Roles = "PortalOwnerChange")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public void OwnerFromForm([FromForm] SettingsModel model)
|
|
{
|
|
Owner(model);
|
|
}
|
|
|
|
private void Owner(SettingsModel model)
|
|
{
|
|
var newOwner = Constants.LostUser;
|
|
try
|
|
{
|
|
newOwner = UserManager.GetUsers(model.OwnerId);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
if (Constants.LostUser.Equals(newOwner))
|
|
{
|
|
throw new Exception(Resource.ErrorUserNotFound);
|
|
}
|
|
|
|
if (UserManager.IsUserInGroup(newOwner.ID, Constants.GroupVisitor.ID))
|
|
{
|
|
throw new Exception(Resource.ErrorUserNotFound);
|
|
}
|
|
|
|
var curTenant = TenantManager.GetCurrentTenant();
|
|
curTenant.OwnerId = newOwner.ID;
|
|
TenantManager.SaveTenant(curTenant);
|
|
|
|
MessageService.Send(MessageAction.OwnerUpdated, newOwner.DisplayUserName(false, DisplayUserSettingsHelper));
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Update("defaultpage")]
|
|
public object SaveDefaultPageSettingsFromBody([FromBody]SettingsModel model)
|
|
{
|
|
return SaveDefaultPageSettings(model);
|
|
}
|
|
|
|
[Update("defaultpage")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public object SaveDefaultPageSettingsFromForm([FromForm] SettingsModel model)
|
|
{
|
|
return SaveDefaultPageSettings(model);
|
|
}
|
|
|
|
private object SaveDefaultPageSettings(SettingsModel model)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
SettingsManager.Save(new StudioDefaultPageSettings { DefaultProductID = model.DefaultProductID });
|
|
|
|
MessageService.Send(MessageAction.DefaultStartPageSettingsUpdated);
|
|
|
|
return Resource.SuccessfullySaveSettingsMessage;
|
|
}
|
|
|
|
|
|
private string GetProductName(Guid productId)
|
|
{
|
|
var product = WebItemManager[productId];
|
|
return productId == Guid.Empty ? "All" : product != null ? product.Name : productId.ToString();
|
|
}
|
|
|
|
[Read("license/refresh", Check = false)]
|
|
public bool RefreshLicense()
|
|
{
|
|
if (!CoreBaseSettings.Standalone) return false;
|
|
LicenseReader.RefreshLicense();
|
|
return true;
|
|
}
|
|
|
|
[Create("license/accept", Check = false)]
|
|
public object AcceptLicense()
|
|
{
|
|
if (!CoreBaseSettings.Standalone) return "";
|
|
|
|
TariffSettings.SetLicenseAccept(SettingsManager);
|
|
MessageService.Send(MessageAction.LicenseKeyUploaded);
|
|
|
|
try
|
|
{
|
|
LicenseReader.RefreshLicense();
|
|
}
|
|
catch (BillingNotFoundException)
|
|
{
|
|
return UserControlsCommonResource.LicenseKeyNotFound;
|
|
}
|
|
catch (BillingNotConfiguredException)
|
|
{
|
|
return UserControlsCommonResource.LicenseKeyNotCorrect;
|
|
}
|
|
catch (BillingException)
|
|
{
|
|
return UserControlsCommonResource.LicenseException;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
return ex.Message;
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
[AllowAnonymous]
|
|
[Read("license/required", Check = false)]
|
|
public bool RequestLicense()
|
|
{
|
|
return FirstTimeTenantSettings.RequestLicense;
|
|
}
|
|
|
|
|
|
[Create("license", Check = false)]
|
|
[Authorize(AuthenticationSchemes = "confirm", Roles = "Wizard, Administrators")]
|
|
public object UploadLicense([FromForm] UploadLicenseModel model)
|
|
{
|
|
try
|
|
{
|
|
ApiContext.AuthByClaim();
|
|
if (!AuthContext.IsAuthenticated && SettingsManager.Load<WizardSettings>().Completed) throw new SecurityException(Resource.PortalSecurity);
|
|
if (!model.Files.Any()) throw new Exception(Resource.ErrorEmptyUploadFileSelected);
|
|
|
|
|
|
|
|
var licenseFile = model.Files.First();
|
|
var dueDate = LicenseReader.SaveLicenseTemp(licenseFile.OpenReadStream());
|
|
|
|
return dueDate >= DateTime.UtcNow.Date
|
|
? Resource.LicenseUploaded
|
|
: string.Format(Resource.LicenseUploadedOverdue,
|
|
"",
|
|
"",
|
|
dueDate.Date.ToLongDateString());
|
|
}
|
|
catch (LicenseExpiredException ex)
|
|
{
|
|
Log.Error("License upload", ex);
|
|
throw new Exception(Resource.LicenseErrorExpired);
|
|
}
|
|
catch (LicenseQuotaException ex)
|
|
{
|
|
Log.Error("License upload", ex);
|
|
throw new Exception(Resource.LicenseErrorQuota);
|
|
}
|
|
catch (LicensePortalException ex)
|
|
{
|
|
Log.Error("License upload", ex);
|
|
throw new Exception(Resource.LicenseErrorPortal);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Log.Error("License upload", ex);
|
|
throw new Exception(Resource.LicenseError);
|
|
}
|
|
}
|
|
|
|
|
|
[Read("customnavigation/getall")]
|
|
public List<CustomNavigationItem> GetCustomNavigationItems()
|
|
{
|
|
return SettingsManager.Load<CustomNavigationSettings>().Items;
|
|
}
|
|
|
|
[Read("customnavigation/getsample")]
|
|
public CustomNavigationItem GetCustomNavigationItemSample()
|
|
{
|
|
return CustomNavigationItem.GetSample();
|
|
}
|
|
|
|
[Read("customnavigation/get/{id}")]
|
|
public CustomNavigationItem GetCustomNavigationItem(Guid id)
|
|
{
|
|
return SettingsManager.Load<CustomNavigationSettings>().Items.FirstOrDefault(item => item.Id == id);
|
|
}
|
|
|
|
[Create("customnavigation/create")]
|
|
public CustomNavigationItem CreateCustomNavigationItemFromBody([FromBody]CustomNavigationItem item)
|
|
{
|
|
return CreateCustomNavigationItem(item);
|
|
}
|
|
|
|
[Create("customnavigation/create")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public CustomNavigationItem CreateCustomNavigationItemFromForm([FromForm] CustomNavigationItem item)
|
|
{
|
|
return CreateCustomNavigationItem(item);
|
|
}
|
|
|
|
private CustomNavigationItem CreateCustomNavigationItem(CustomNavigationItem item)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
var settings = SettingsManager.Load<CustomNavigationSettings>();
|
|
|
|
var exist = false;
|
|
|
|
foreach (var existItem in settings.Items)
|
|
{
|
|
if (existItem.Id != item.Id) continue;
|
|
|
|
existItem.Label = item.Label;
|
|
existItem.Url = item.Url;
|
|
existItem.ShowInMenu = item.ShowInMenu;
|
|
existItem.ShowOnHomePage = item.ShowOnHomePage;
|
|
|
|
if (existItem.SmallImg != item.SmallImg)
|
|
{
|
|
StorageHelper.DeleteLogo(existItem.SmallImg);
|
|
existItem.SmallImg = StorageHelper.SaveTmpLogo(item.SmallImg);
|
|
}
|
|
|
|
if (existItem.BigImg != item.BigImg)
|
|
{
|
|
StorageHelper.DeleteLogo(existItem.BigImg);
|
|
existItem.BigImg = StorageHelper.SaveTmpLogo(item.BigImg);
|
|
}
|
|
|
|
exist = true;
|
|
break;
|
|
}
|
|
|
|
if (!exist)
|
|
{
|
|
item.Id = Guid.NewGuid();
|
|
item.SmallImg = StorageHelper.SaveTmpLogo(item.SmallImg);
|
|
item.BigImg = StorageHelper.SaveTmpLogo(item.BigImg);
|
|
|
|
settings.Items.Add(item);
|
|
}
|
|
|
|
SettingsManager.Save(settings);
|
|
|
|
MessageService.Send(MessageAction.CustomNavigationSettingsUpdated);
|
|
|
|
return item;
|
|
}
|
|
|
|
[Delete("customnavigation/delete/{id}")]
|
|
public void DeleteCustomNavigationItem(Guid id)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
var settings = SettingsManager.Load<CustomNavigationSettings>();
|
|
|
|
var terget = settings.Items.FirstOrDefault(item => item.Id == id);
|
|
|
|
if (terget == null) return;
|
|
|
|
StorageHelper.DeleteLogo(terget.SmallImg);
|
|
StorageHelper.DeleteLogo(terget.BigImg);
|
|
|
|
settings.Items.Remove(terget);
|
|
SettingsManager.Save(settings);
|
|
|
|
MessageService.Send(MessageAction.CustomNavigationSettingsUpdated);
|
|
}
|
|
|
|
[Update("emailactivation")]
|
|
public EmailActivationSettings UpdateEmailActivationSettingsFromBody([FromBody]EmailActivationSettings settings)
|
|
{
|
|
SettingsManager.SaveForCurrentUser(settings);
|
|
return settings;
|
|
}
|
|
|
|
[Update("emailactivation")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public EmailActivationSettings UpdateEmailActivationSettingsFromForm([FromForm]EmailActivationSettings settings)
|
|
{
|
|
SettingsManager.SaveForCurrentUser(settings);
|
|
return settings;
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Read("companywhitelabel")]
|
|
public List<CompanyWhiteLabelSettings> GetLicensorData()
|
|
{
|
|
var result = new List<CompanyWhiteLabelSettings>();
|
|
|
|
var instance = CompanyWhiteLabelSettings.Instance(SettingsManager);
|
|
|
|
result.Add(instance);
|
|
|
|
if (!instance.IsDefault(CoreSettings) && !instance.GetIsLicensor(TenantManager, CoreSettings))
|
|
{
|
|
result.Add(instance.GetDefault(ServiceProvider) as CompanyWhiteLabelSettings);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
[Read("statistics/spaceusage/{id}")]
|
|
public List<UsageSpaceStatItemWrapper> GetSpaceUsageStatistics(Guid id)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
var webtem = WebItemManagerSecurity.GetItems(WebZoneType.All, ItemAvailableState.All)
|
|
.FirstOrDefault(item =>
|
|
item != null &&
|
|
item.ID == id &&
|
|
item.Context != null &&
|
|
item.Context.SpaceUsageStatManager != null);
|
|
|
|
if (webtem == null) return new List<UsageSpaceStatItemWrapper>();
|
|
|
|
return webtem.Context.SpaceUsageStatManager.GetStatData()
|
|
.ConvertAll(it => new UsageSpaceStatItemWrapper
|
|
{
|
|
Name = it.Name.HtmlEncode(),
|
|
Icon = it.ImgUrl,
|
|
Disabled = it.Disabled,
|
|
Size = FileSizeComment.FilesSizeToString(it.SpaceUsage),
|
|
Url = it.Url
|
|
});
|
|
}
|
|
|
|
[Read("statistics/visit")]
|
|
public List<ChartPointWrapper> GetVisitStatistics(ApiDateTime fromDate, ApiDateTime toDate)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
var from = TenantUtil.DateTimeFromUtc(fromDate);
|
|
var to = TenantUtil.DateTimeFromUtc(toDate);
|
|
|
|
var points = new List<ChartPointWrapper>();
|
|
|
|
if (from.CompareTo(to) >= 0) return points;
|
|
|
|
for (var d = new DateTime(from.Ticks); d.Date.CompareTo(to.Date) <= 0; d = d.AddDays(1))
|
|
{
|
|
points.Add(new ChartPointWrapper
|
|
{
|
|
DisplayDate = d.Date.ToShortDateString(),
|
|
Date = d.Date,
|
|
Hosts = 0,
|
|
Hits = 0
|
|
});
|
|
}
|
|
|
|
var hits = StatisticManager.GetHitsByPeriod(Tenant.TenantId, from, to);
|
|
var hosts = StatisticManager.GetHostsByPeriod(Tenant.TenantId, from, to);
|
|
|
|
if (hits.Count == 0 || hosts.Count == 0) return points;
|
|
|
|
hits.Sort((x, y) => x.VisitDate.CompareTo(y.VisitDate));
|
|
hosts.Sort((x, y) => x.VisitDate.CompareTo(y.VisitDate));
|
|
|
|
for (int i = 0, n = points.Count, hitsNum = 0, hostsNum = 0; i < n; i++)
|
|
{
|
|
while (hitsNum < hits.Count && points[i].Date.CompareTo(hits[hitsNum].VisitDate.Date) == 0)
|
|
{
|
|
points[i].Hits += hits[hitsNum].VisitCount;
|
|
hitsNum++;
|
|
}
|
|
while (hostsNum < hosts.Count && points[i].Date.CompareTo(hosts[hostsNum].VisitDate.Date) == 0)
|
|
{
|
|
points[i].Hosts++;
|
|
hostsNum++;
|
|
}
|
|
}
|
|
|
|
return points;
|
|
}
|
|
|
|
[Read("storage")]
|
|
public List<StorageWrapper> GetAllStorages()
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
TenantExtra.DemandControlPanelPermission();
|
|
|
|
var current = SettingsManager.Load<StorageSettings>();
|
|
var consumers = ConsumerFactory.GetAll<DataStoreConsumer>().ToList();
|
|
return consumers.Select(consumer => new StorageWrapper(consumer, current)).ToList();
|
|
}
|
|
|
|
[Read("storage/progress", false)]
|
|
public double GetStorageProgress()
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
if (!CoreBaseSettings.Standalone) return -1;
|
|
|
|
return ServiceClient.GetProgress(Tenant.TenantId);
|
|
}
|
|
|
|
public readonly object Locker = new object();
|
|
|
|
[Create("encryption/start")]
|
|
public bool StartStorageEncryptionFromBody([FromBody]StorageEncryptionModel storageEncryption)
|
|
{
|
|
return StartStorageEncryption(storageEncryption);
|
|
}
|
|
|
|
[Create("encryption/start")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public bool StartStorageEncryptionFromForm([FromForm] StorageEncryptionModel storageEncryption)
|
|
{
|
|
return StartStorageEncryption(storageEncryption);
|
|
}
|
|
|
|
private bool StartStorageEncryption(StorageEncryptionModel storageEncryption)
|
|
{
|
|
lock (Locker)
|
|
{
|
|
var activeTenants = TenantManager.GetTenants();
|
|
|
|
if (activeTenants.Any())
|
|
{
|
|
StartEncryption(storageEncryption.NotifyUsers);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void StartEncryption(bool notifyUsers)
|
|
{
|
|
if (!SetupInfo.IsVisibleSettings<EncryptionSettings>())
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
if (!CoreBaseSettings.Standalone)
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
TenantExtra.DemandControlPanelPermission();
|
|
|
|
if (!TenantManager.GetTenantQuota(TenantManager.GetCurrentTenant().TenantId).DiscEncryption)
|
|
{
|
|
throw new BillingException(Resource.ErrorNotAllowedOption, "DiscEncryption");
|
|
}
|
|
|
|
var storages = GetAllStorages();
|
|
|
|
if (storages.Any(s => s.Current))
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
var cdnStorages = GetAllCdnStorages();
|
|
|
|
if (cdnStorages.Any(s => s.Current))
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
var tenants = TenantManager.GetTenants();
|
|
|
|
foreach (var tenant in tenants)
|
|
{
|
|
var progress = BackupServiceNotifier.GetBackupProgress(tenant.TenantId);
|
|
if (progress != null && progress.IsCompleted == false)
|
|
{
|
|
throw new Exception();
|
|
}
|
|
}
|
|
|
|
foreach (var tenant in tenants)
|
|
{
|
|
CacheDeleteSchedule.Publish(new DeleteSchedule() { TenantId = tenant.TenantId }, CacheNotifyAction.Insert);
|
|
}
|
|
|
|
var settings = EncryptionSettingsHelper.Load();
|
|
|
|
settings.NotifyUsers = notifyUsers;
|
|
|
|
if (settings.Status == EncryprtionStatus.Decrypted)
|
|
{
|
|
settings.Status = EncryprtionStatus.EncryptionStarted;
|
|
settings.Password = EncryptionSettingsHelper.GeneratePassword(32, 16);
|
|
}
|
|
else if (settings.Status == EncryprtionStatus.Encrypted)
|
|
{
|
|
settings.Status = EncryprtionStatus.DecryptionStarted;
|
|
}
|
|
|
|
MessageService.Send(settings.Status == EncryprtionStatus.EncryptionStarted ? MessageAction.StartStorageEncryption : MessageAction.StartStorageDecryption);
|
|
|
|
var serverRootPath = CommonLinkUtility.GetFullAbsolutePath("~").TrimEnd('/');
|
|
|
|
foreach (var tenant in tenants)
|
|
{
|
|
TenantManager.SetCurrentTenant(tenant);
|
|
|
|
if (notifyUsers)
|
|
{
|
|
if (settings.Status == EncryprtionStatus.EncryptionStarted)
|
|
{
|
|
StudioNotifyService.SendStorageEncryptionStart(serverRootPath);
|
|
}
|
|
else
|
|
{
|
|
StudioNotifyService.SendStorageDecryptionStart(serverRootPath);
|
|
}
|
|
}
|
|
|
|
tenant.SetStatus(TenantStatus.Encryption);
|
|
TenantManager.SaveTenant(tenant);
|
|
}
|
|
|
|
EncryptionSettingsHelper.Save(settings);
|
|
|
|
var encryptionSettingsProto = new EncryptionSettingsProto
|
|
{
|
|
NotifyUsers = settings.NotifyUsers,
|
|
Password = settings.Password,
|
|
Status = settings.Status,
|
|
ServerRootPath = serverRootPath
|
|
};
|
|
EncryptionServiceClient.Start(encryptionSettingsProto);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get storage encryption settings
|
|
/// </summary>
|
|
/// <returns>EncryptionSettings</returns>
|
|
/// <visible>false</visible>
|
|
[Read("encryption/settings")]
|
|
public EncryptionSettings GetStorageEncryptionSettings()
|
|
{
|
|
try
|
|
{
|
|
if (!SetupInfo.IsVisibleSettings<EncryptionSettings>())
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
if (!CoreBaseSettings.Standalone)
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
|
|
TenantExtra.DemandControlPanelPermission();
|
|
|
|
if (!TenantManager.GetTenantQuota(TenantManager.GetCurrentTenant().TenantId).DiscEncryption)
|
|
{
|
|
throw new BillingException(Resource.ErrorNotAllowedOption, "DiscEncryption");
|
|
}
|
|
|
|
var settings = EncryptionSettingsHelper.Load();
|
|
|
|
settings.Password = string.Empty; // Don't show password
|
|
|
|
return settings;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Error("GetStorageEncryptionSettings", e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
[Read("encryption/progress")]
|
|
public double? GetStorageEncryptionProgress()
|
|
{
|
|
if (!SetupInfo.IsVisibleSettings<EncryptionSettings>())
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
if (!CoreBaseSettings.Standalone)
|
|
{
|
|
throw new NotSupportedException();
|
|
}
|
|
|
|
if (!TenantManager.GetTenantQuota(TenantManager.GetCurrentTenant().TenantId).DiscEncryption)
|
|
{
|
|
throw new BillingException(Resource.ErrorNotAllowedOption, "DiscEncryption");
|
|
}
|
|
|
|
return EncryptionServiceNotifier.GetEncryptionProgress(Tenant.TenantId)?.Progress;
|
|
}
|
|
|
|
[Update("storage")]
|
|
public StorageSettings UpdateStorageFromBody([FromBody]StorageModel model)
|
|
{
|
|
return UpdateStorage(model);
|
|
}
|
|
|
|
[Update("storage")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public StorageSettings UpdateStorageFromForm([FromForm] StorageModel model)
|
|
{
|
|
return UpdateStorage(model);
|
|
}
|
|
|
|
private StorageSettings UpdateStorage(StorageModel model)
|
|
{
|
|
try
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
if (!CoreBaseSettings.Standalone) return null;
|
|
|
|
TenantExtra.DemandControlPanelPermission();
|
|
|
|
var consumer = ConsumerFactory.GetByKey(model.Module);
|
|
if (!consumer.IsSet)
|
|
throw new ArgumentException("module");
|
|
|
|
var settings = SettingsManager.Load<StorageSettings>();
|
|
if (settings.Module == model.Module) return settings;
|
|
|
|
settings.Module = model.Module;
|
|
settings.Props = model.Props.ToDictionary(r => r.Key, b => b.Value);
|
|
|
|
StartMigrate(settings);
|
|
return settings;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Error("UpdateStorage", e);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
[Delete("storage")]
|
|
public void ResetStorageToDefault()
|
|
{
|
|
try
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
if (!CoreBaseSettings.Standalone) return;
|
|
|
|
TenantExtra.DemandControlPanelPermission();
|
|
|
|
var settings = SettingsManager.Load<StorageSettings>();
|
|
|
|
settings.Module = null;
|
|
settings.Props = null;
|
|
|
|
|
|
StartMigrate(settings);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Error("ResetStorageToDefault", e);
|
|
throw;
|
|
}
|
|
}
|
|
|
|
[Read("storage/cdn")]
|
|
public List<StorageWrapper> GetAllCdnStorages()
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
if (!CoreBaseSettings.Standalone) return null;
|
|
|
|
TenantExtra.DemandControlPanelPermission();
|
|
|
|
var current = SettingsManager.Load<CdnStorageSettings>();
|
|
var consumers = ConsumerFactory.GetAll<DataStoreConsumer>().Where(r => r.Cdn != null).ToList();
|
|
return consumers.Select(consumer => new StorageWrapper(consumer, current)).ToList();
|
|
}
|
|
|
|
[Update("storage/cdn")]
|
|
public CdnStorageSettings UpdateCdnFromBody([FromBody]StorageModel model)
|
|
{
|
|
return UpdateCdn(model);
|
|
}
|
|
|
|
[Update("storage/cdn")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public CdnStorageSettings UpdateCdnFromForm([FromForm] StorageModel model)
|
|
{
|
|
return UpdateCdn(model);
|
|
}
|
|
|
|
private CdnStorageSettings UpdateCdn(StorageModel model)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
if (!CoreBaseSettings.Standalone) return null;
|
|
|
|
TenantExtra.DemandControlPanelPermission();
|
|
|
|
var consumer = ConsumerFactory.GetByKey(model.Module);
|
|
if (!consumer.IsSet)
|
|
throw new ArgumentException("module");
|
|
|
|
var settings = SettingsManager.Load<CdnStorageSettings>();
|
|
if (settings.Module == model.Module) return settings;
|
|
|
|
settings.Module = model.Module;
|
|
settings.Props = model.Props.ToDictionary(r => r.Key, b => b.Value);
|
|
|
|
try
|
|
{
|
|
ServiceClient.UploadCdn(Tenant.TenantId, "/", WebHostEnvironment.ContentRootPath, settings);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Error("UpdateCdn", e);
|
|
throw;
|
|
}
|
|
|
|
return settings;
|
|
}
|
|
|
|
[Delete("storage/cdn")]
|
|
public void ResetCdnToDefault()
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
if (!CoreBaseSettings.Standalone) return;
|
|
|
|
TenantExtra.DemandControlPanelPermission();
|
|
|
|
StorageSettingsHelper.Clear(SettingsManager.Load<CdnStorageSettings>());
|
|
}
|
|
|
|
[Read("storage/backup")]
|
|
public List<StorageWrapper> GetAllBackupStorages()
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
if (CoreBaseSettings.Standalone)
|
|
{
|
|
TenantExtra.DemandControlPanelPermission();
|
|
}
|
|
var schedule = BackupAjaxHandler.GetSchedule();
|
|
var current = new StorageSettings();
|
|
|
|
if (schedule != null && schedule.StorageType == BackupStorageType.ThirdPartyConsumer)
|
|
{
|
|
current = new StorageSettings
|
|
{
|
|
Module = schedule.StorageParams["module"],
|
|
Props = schedule.StorageParams.Where(r => r.Key != "module").ToDictionary(r => r.Key, r => r.Value)
|
|
};
|
|
}
|
|
|
|
var consumers = ConsumerFactory.GetAll<DataStoreConsumer>().ToList();
|
|
return consumers.Select(consumer => new StorageWrapper(consumer, current)).ToList();
|
|
}
|
|
|
|
private void StartMigrate(StorageSettings settings)
|
|
{
|
|
ServiceClient.Migrate(Tenant.TenantId, settings);
|
|
|
|
Tenant.SetStatus(TenantStatus.Migrating);
|
|
TenantManager.SaveTenant(Tenant);
|
|
}
|
|
|
|
[Read("socket")]
|
|
public object GetSocketSettings()
|
|
{
|
|
var hubUrl = Configuration["web:hub"] ?? string.Empty;
|
|
if (hubUrl != string.Empty)
|
|
{
|
|
if (!hubUrl.EndsWith("/"))
|
|
{
|
|
hubUrl += "/";
|
|
}
|
|
}
|
|
|
|
return new { Url = hubUrl };
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Read("controlpanel")]
|
|
public TenantControlPanelSettings GetTenantControlPanelSettings()
|
|
{
|
|
return SettingsManager.Load<TenantControlPanelSettings>();
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Create("rebranding/company")]
|
|
public bool SaveCompanyWhiteLabelSettingsFromBody([FromBody] CompanyWhiteLabelSettingsWrapper companyWhiteLabelSettingsWrapper)
|
|
{
|
|
return SaveCompanyWhiteLabelSettings(companyWhiteLabelSettingsWrapper);
|
|
}
|
|
|
|
[Create("rebranding/company")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public bool SaveCompanyWhiteLabelSettingsFromForm([FromForm] CompanyWhiteLabelSettingsWrapper companyWhiteLabelSettingsWrapper)
|
|
{
|
|
return SaveCompanyWhiteLabelSettings(companyWhiteLabelSettingsWrapper);
|
|
}
|
|
|
|
private bool SaveCompanyWhiteLabelSettings(CompanyWhiteLabelSettingsWrapper companyWhiteLabelSettingsWrapper)
|
|
{
|
|
if (companyWhiteLabelSettingsWrapper.Settings == null) throw new ArgumentNullException("settings");
|
|
|
|
DemandRebrandingPermission();
|
|
|
|
companyWhiteLabelSettingsWrapper.Settings.IsLicensorSetting = false; //TODO: CoreContext.TenantManager.GetTenantQuota(TenantProvider.CurrentTenantID).Branding && settings.IsLicensor
|
|
|
|
SettingsManager.SaveForDefaultTenant(companyWhiteLabelSettingsWrapper.Settings);
|
|
return true;
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Read("rebranding/company")]
|
|
public CompanyWhiteLabelSettings GetCompanyWhiteLabelSettings()
|
|
{
|
|
return SettingsManager.LoadForDefaultTenant<CompanyWhiteLabelSettings>();
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Delete("rebranding/company")]
|
|
public CompanyWhiteLabelSettings DeleteCompanyWhiteLabelSettings()
|
|
{
|
|
DemandRebrandingPermission();
|
|
|
|
var defaultSettings = (CompanyWhiteLabelSettings)SettingsManager.LoadForDefaultTenant<CompanyWhiteLabelSettings>().GetDefault(CoreSettings);
|
|
|
|
SettingsManager.SaveForDefaultTenant(defaultSettings);
|
|
|
|
return defaultSettings;
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Create("rebranding/additional")]
|
|
public bool SaveAdditionalWhiteLabelSettingsFromBody([FromBody]AdditionalWhiteLabelSettingsWrapper wrapper)
|
|
{
|
|
return SaveAdditionalWhiteLabelSettings(wrapper);
|
|
}
|
|
|
|
[Create("rebranding/additional")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public bool SaveAdditionalWhiteLabelSettingsFromForm([FromForm] AdditionalWhiteLabelSettingsWrapper wrapper)
|
|
{
|
|
return SaveAdditionalWhiteLabelSettings(wrapper);
|
|
}
|
|
|
|
private bool SaveAdditionalWhiteLabelSettings(AdditionalWhiteLabelSettingsWrapper wrapper)
|
|
{
|
|
if (wrapper.Settings == null) throw new ArgumentNullException("settings");
|
|
|
|
DemandRebrandingPermission();
|
|
|
|
SettingsManager.SaveForDefaultTenant(wrapper.Settings);
|
|
return true;
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Read("rebranding/additional")]
|
|
public AdditionalWhiteLabelSettings GetAdditionalWhiteLabelSettings()
|
|
{
|
|
return SettingsManager.LoadForDefaultTenant<AdditionalWhiteLabelSettings>();
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Delete("rebranding/additional")]
|
|
public AdditionalWhiteLabelSettings DeleteAdditionalWhiteLabelSettings()
|
|
{
|
|
DemandRebrandingPermission();
|
|
|
|
var defaultSettings = (AdditionalWhiteLabelSettings)SettingsManager.LoadForDefaultTenant<AdditionalWhiteLabelSettings>().GetDefault(Configuration);
|
|
|
|
SettingsManager.SaveForDefaultTenant(defaultSettings);
|
|
|
|
return defaultSettings;
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Create("rebranding/mail")]
|
|
public bool SaveMailWhiteLabelSettingsFromBody([FromBody] MailWhiteLabelSettings settings)
|
|
{
|
|
return SaveMailWhiteLabelSettings(settings);
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Create("rebranding/mail")]
|
|
public bool SaveMailWhiteLabelSettingsFromForm([FromForm] MailWhiteLabelSettings settings)
|
|
{
|
|
return SaveMailWhiteLabelSettings(settings);
|
|
}
|
|
|
|
private bool SaveMailWhiteLabelSettings(MailWhiteLabelSettings settings)
|
|
{
|
|
if (settings == null) throw new ArgumentNullException("settings");
|
|
|
|
DemandRebrandingPermission();
|
|
|
|
SettingsManager.SaveForDefaultTenant(settings);
|
|
return true;
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Update("rebranding/mail")]
|
|
public bool UpdateMailWhiteLabelSettingsFromBody([FromBody]MailWhiteLabelSettingsModel model)
|
|
{
|
|
return UpdateMailWhiteLabelSettings(model);
|
|
}
|
|
|
|
[Update("rebranding/mail")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public bool UpdateMailWhiteLabelSettingsFromForm([FromForm]MailWhiteLabelSettingsModel model)
|
|
{
|
|
return UpdateMailWhiteLabelSettings(model);
|
|
}
|
|
|
|
private bool UpdateMailWhiteLabelSettings(MailWhiteLabelSettingsModel model)
|
|
{
|
|
DemandRebrandingPermission();
|
|
|
|
var settings = SettingsManager.LoadForDefaultTenant<MailWhiteLabelSettings>();
|
|
|
|
settings.FooterEnabled = model.FooterEnabled;
|
|
|
|
SettingsManager.SaveForDefaultTenant(settings);
|
|
|
|
return true;
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Read("rebranding/mail")]
|
|
public MailWhiteLabelSettings GetMailWhiteLabelSettings()
|
|
{
|
|
return SettingsManager.LoadForDefaultTenant<MailWhiteLabelSettings>();
|
|
}
|
|
|
|
///<visible>false</visible>
|
|
[Delete("rebranding/mail")]
|
|
public MailWhiteLabelSettings DeleteMailWhiteLabelSettings()
|
|
{
|
|
DemandRebrandingPermission();
|
|
|
|
var defaultSettings = (MailWhiteLabelSettings)SettingsManager.LoadForDefaultTenant<MailWhiteLabelSettings>().GetDefault(Configuration);
|
|
|
|
SettingsManager.SaveForDefaultTenant(defaultSettings);
|
|
|
|
return defaultSettings;
|
|
}
|
|
|
|
private void DemandRebrandingPermission()
|
|
{
|
|
TenantExtra.DemandControlPanelPermission();
|
|
|
|
if (!TenantManager.GetTenantQuota(Tenant.TenantId).SSBranding)
|
|
{
|
|
throw new BillingException(Resource.ErrorNotAllowedOption, "SSBranding");
|
|
}
|
|
|
|
if (CoreBaseSettings.CustomMode)
|
|
{
|
|
throw new SecurityException();
|
|
}
|
|
}
|
|
|
|
[Read("authservice")]
|
|
public IEnumerable<AuthServiceModel> GetAuthServices()
|
|
{
|
|
return ConsumerFactory.GetAll<Consumer>()
|
|
.Where(consumer => consumer.ManagedKeys.Any())
|
|
.OrderBy(services => services.Order)
|
|
.Select(r => new AuthServiceModel(r))
|
|
.ToList();
|
|
}
|
|
|
|
[Create("authservice")]
|
|
public bool SaveAuthKeysFromBody([FromBody]AuthServiceModel model)
|
|
{
|
|
return SaveAuthKeys(model);
|
|
}
|
|
|
|
[Create("authservice")]
|
|
[Consumes("application/x-www-form-urlencoded")]
|
|
public bool SaveAuthKeysFromForm([FromForm] AuthServiceModel model)
|
|
{
|
|
return SaveAuthKeys(model);
|
|
}
|
|
|
|
private bool SaveAuthKeys(AuthServiceModel model)
|
|
{
|
|
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
|
|
if (!SetupInfo.IsVisibleSettings(ManagementType.ThirdPartyAuthorization.ToString()))
|
|
throw new BillingException(Resource.ErrorNotAllowedOption, "ThirdPartyAuthorization");
|
|
|
|
var changed = false;
|
|
var consumer = ConsumerFactory.GetByKey<Consumer>(model.Name);
|
|
|
|
var validateKeyProvider = consumer as IValidateKeysProvider;
|
|
|
|
if (validateKeyProvider != null)
|
|
{
|
|
try
|
|
{
|
|
if (validateKeyProvider is TwilioProvider twilioLoginProvider)
|
|
{
|
|
twilioLoginProvider.ClearOldNumbers();
|
|
}
|
|
if (validateKeyProvider is BitlyLoginProvider bitly)
|
|
{
|
|
UrlShortener.Instance = null;
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Log.Error(e);
|
|
}
|
|
}
|
|
|
|
if (model.Props.All(r => string.IsNullOrEmpty(r.Value)))
|
|
{
|
|
consumer.Clear();
|
|
changed = true;
|
|
}
|
|
else
|
|
{
|
|
foreach (var authKey in model.Props.Where(authKey => consumer[authKey.Name] != authKey.Value))
|
|
{
|
|
consumer[authKey.Name] = authKey.Value;
|
|
changed = true;
|
|
}
|
|
}
|
|
if (validateKeyProvider != null && !validateKeyProvider.ValidateKeys() && !consumer.All(r => string.IsNullOrEmpty(r.Value)))
|
|
{
|
|
consumer.Clear();
|
|
throw new ArgumentException(Resource.ErrorBadKeys);
|
|
}
|
|
|
|
if (changed)
|
|
MessageService.Send(MessageAction.AuthorizationKeysSetting);
|
|
|
|
return changed;
|
|
}
|
|
|
|
[Read("payment", Check = false)]
|
|
public object PaymentSettings()
|
|
{
|
|
var settings = SettingsManager.LoadForDefaultTenant<AdditionalWhiteLabelSettings>();
|
|
var currentQuota = TenantExtra.GetTenantQuota();
|
|
var currentTariff = TenantExtra.GetCurrentTariff();
|
|
|
|
return
|
|
new
|
|
{
|
|
settings.SalesEmail,
|
|
settings.FeedbackAndSupportUrl,
|
|
settings.BuyUrl,
|
|
CoreBaseSettings.Standalone,
|
|
currentLicense = new
|
|
{
|
|
currentQuota.Trial,
|
|
currentTariff.DueDate.Date
|
|
}
|
|
};
|
|
}
|
|
|
|
/// <visible>false</visible>
|
|
/// <summary>
|
|
/// Gets a link that will connect TelegramBot to your account
|
|
/// </summary>
|
|
/// <returns>url</returns>
|
|
///
|
|
[Read("telegramlink")]
|
|
public object TelegramLink()
|
|
{
|
|
var currentLink = TelegramHelper.CurrentRegistrationLink(AuthContext.CurrentAccount.ID, Tenant.TenantId);
|
|
|
|
if (string.IsNullOrEmpty(currentLink))
|
|
{
|
|
var url = TelegramHelper.RegisterUser(AuthContext.CurrentAccount.ID, Tenant.TenantId);
|
|
return url;
|
|
}
|
|
else
|
|
{
|
|
return currentLink;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Checks if user has connected TelegramBot
|
|
/// </summary>
|
|
/// <returns>0 - not connected, 1 - connected, 2 - awaiting confirmation</returns>
|
|
[Read("telegramisconnected")]
|
|
public object TelegramIsConnected()
|
|
{
|
|
return (int)TelegramHelper.UserIsConnected(AuthContext.CurrentAccount.ID, Tenant.TenantId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Unlinks TelegramBot from your account
|
|
/// </summary>
|
|
[Delete("telegramdisconnect")]
|
|
public void TelegramDisconnect()
|
|
{
|
|
TelegramHelper.Disconnect(AuthContext.CurrentAccount.ID, Tenant.TenantId);
|
|
}
|
|
|
|
private readonly int maxCount = 10;
|
|
private readonly int expirationMinutes = 2;
|
|
private void CheckCache(string basekey)
|
|
{
|
|
var key = ApiContext.HttpContextAccessor.HttpContext.Request.GetUserHostAddress() + basekey;
|
|
if (MemoryCache.TryGetValue<int>(key, out var count))
|
|
{
|
|
if (count > maxCount)
|
|
throw new Exception(Resource.ErrorRequestLimitExceeded);
|
|
}
|
|
|
|
MemoryCache.Set(key, ++count, TimeSpan.FromMinutes(expirationMinutes));
|
|
}
|
|
}
|
|
} |