public ItemList<FileOperationResult> Download(AuthContext authContext, TenantManager tenantManager, Dictionary<JsonElement, string> folders, Dictionary<JsonElement, string> files, IDictionary<string, StringValues> headers)
{
var operations = tasks.GetTasks()
.Where(t => t.GetProperty<Guid>(FileOperation.OWNER) == authContext.CurrentAccount.ID)
.Where(t => t.GetProperty<FileOperationType>(FileOperation.OPERATION_TYPE) == FileOperationType.Download);
if (operations.Any(o => o.Status <= DistributedTaskStatus.Running))
{
throw new InvalidOperationException(FilesCommonResource.ErrorMassage_ManyDownloads);
}
var tenant = tenantManager.GetCurrentTenant();
var op1 = new FileDownloadOperation<int>(ServiceProvider, new FileDownloadOperationData<int>(folders.Where(r => r.Key.ValueKind == JsonValueKind.Number).ToDictionary(r => r.Key.GetInt32(), r => r.Value), files.Where(r => r.Key.ValueKind == JsonValueKind.Number).ToDictionary(r => r.Key.GetInt32(), r => r.Value), tenant, headers), false);
var op2 = new FileDownloadOperation<string>(ServiceProvider, new FileDownloadOperationData<string>(folders.Where(r => r.Key.ValueKind == JsonValueKind.String).ToDictionary(r => r.Key.GetString(), r => r.Value), files.Where(r => r.Key.ValueKind == JsonValueKind.String).ToDictionary(r => r.Key.GetString(), r => r.Value), tenant, headers), false);
var op = new FileDownloadOperation(ServiceProvider, op2, op1);
return QueueTask(authContext, op);
}
/// <summary>
/// Get logo stream or null in case of default logo
/// </summary>
public Stream GetStorageLogoData(TenantInfoSettings tenantInfoSettings)
{
if (tenantInfoSettings._isDefault)
{
return(null);
}
var storage = StorageFactory.GetStorage(TenantManager.GetCurrentTenant().TenantId.ToString(CultureInfo.InvariantCulture), "logo");
if (storage == null)
{
return(null);
}
var fileName = tenantInfoSettings._companyLogoFileName ?? "";
return(storage.IsFile(fileName) ? storage.GetReadStream(fileName) : null);
}
public void ClearOldNumbers(DbContextManager <VoipDbContext> dbOptions, AuthContext authContext, TenantUtil tenantUtil, SecurityContext securityContext, TenantManager tenantManager, BaseCommonLinkUtility baseCommonLinkUtility, VoipDaoCache voipDaoCache)
{
if (string.IsNullOrEmpty(Key) || string.IsNullOrEmpty(Secret))
{
return;
}
var provider = new VoipService.Twilio.TwilioProvider(Key, Secret, authContext, tenantUtil, securityContext, baseCommonLinkUtility);
var dao = new CachedVoipDao(tenantManager.GetCurrentTenant().TenantId, dbOptions, authContext, tenantUtil, securityContext, baseCommonLinkUtility, ConsumerFactory, voipDaoCache);
var numbers = dao.GetNumbers();
foreach (var number in numbers)
{
provider.DisablePhone(number);
dao.DeleteNumber(number.Id);
}
}
public Task <string> UploadFileAsync(string relativePath, string mappedPath, Action <string> onComplete = null)
{
var tenantId = TenantManager.GetCurrentTenant().TenantId;
var task = new Task <string>(() =>
{
using var scope = ServiceProvider.CreateScope();
var tenantManager = scope.ServiceProvider.GetService <TenantManager>();
tenantManager.SetCurrentTenant(tenantId);
var staticUploader = scope.ServiceProvider.GetService <StaticUploader>();
return(staticUploader.UploadFile(relativePath, mappedPath, onComplete));
}, TaskCreationOptions.LongRunning);
task.ConfigureAwait(false);
task.Start(Scheduler);
return(task);
}
public TenantAuditSettings SetAuditSettings(TenantAuditSettings settings)
{
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
if (settings.LoginHistoryLifeTime <= 0 || settings.LoginHistoryLifeTime > TenantAuditSettings.MaxLifeTime)
{
throw new ArgumentException("LoginHistoryLifeTime");
}
if (settings.AuditTrailLifeTime <= 0 || settings.AuditTrailLifeTime > TenantAuditSettings.MaxLifeTime)
{
throw new ArgumentException("AuditTrailLifeTime");
}
SettingsManager.SaveForTenant(settings, TenantManager.GetCurrentTenant().TenantId);
MessageService.Send(MessageAction.AuditSettingsUpdated);
return(settings);
}
public int GetNewFeedsCount(DateTime lastReadedTime, AuthContext authContext, TenantManager tenantManager)
{
var q = new SqlQuery("feed_aggregate a")
.Select("id")
.Where("a.tenant", tenantManager.GetCurrentTenant().TenantId)
.Where(!Exp.Eq("a.modified_by", authContext.CurrentAccount.ID))
.InnerJoin("feed_users u", Exp.EqColumns("a.id", "u.feed_id"))
.Where("u.user_id", authContext.CurrentAccount.ID)
.SetMaxResults(1001);
if (1 < lastReadedTime.Year)
{
q.Where(Exp.Ge("a.aggregated_date", lastReadedTime));
}
var db = GetDb();
return(db.ExecuteList(q).Count());
}
public ThirdPartyProviderDao(
IServiceProvider serviceProvider,
UserManager userManager,
TenantManager tenantManager,
TenantUtil tenantUtil,
DbContextManager <FilesDbContext> dbContextManager,
SetupInfo setupInfo,
IOptionsMonitor <ILog> monitor,
FileUtility fileUtility)
{
ServiceProvider = serviceProvider;
UserManager = userManager;
TenantUtil = tenantUtil;
FilesDbContext = dbContextManager.Get(FileConstant.DatabaseId);
SetupInfo = setupInfo;
Log = monitor.CurrentValue;
FileUtility = fileUtility;
TenantID = tenantManager.GetCurrentTenant().TenantId;
}
public string ReplaceCommunityAdress(string url)
{
var docServicePortalUrl = FilesLinkUtility.DocServicePortalUrl;
if (string.IsNullOrEmpty(url))
{
return(url);
}
if (string.IsNullOrEmpty(docServicePortalUrl))
{
Tenant tenant;
if (!TenantExtra.Saas ||
string.IsNullOrEmpty((tenant = TenantManager.GetCurrentTenant()).MappedDomain) ||
!url.StartsWith("https://" + tenant.MappedDomain))
{
return(url);
}
docServicePortalUrl = "https://" + tenant.GetTenantDomain(CoreSettings, false);
}
var uri = new UriBuilder(url);
if (new UriBuilder(BaseCommonLinkUtility.ServerRootPath).Host != uri.Host)
{
return(url);
}
var urlRewriterQuery = uri.Scheme + Uri.SchemeDelimiter + uri.Host + ":" + uri.Port;
var query = HttpUtility.ParseQueryString(uri.Query);
query[HttpRequestExtensions.UrlRewriterHeader] = urlRewriterQuery;
uri.Query = query.ToString();
var communityUrl = new UriBuilder(docServicePortalUrl);
uri.Scheme = communityUrl.Scheme;
uri.Host = communityUrl.Host;
uri.Port = communityUrl.Port;
return(uri.ToString());
}
public Global(StorageFactory storageFactory,
SecurityContext securityContext,
SetupInfo setupInfo,
FilesLinkUtility filesLinkUtility,
CrmSecurity crmSecurity,
TenantManager tenantManager,
SettingsManager settingsManager,
IConfiguration configuration
)
{
_storageFactory = storageFactory;
_filesLinkUtility = filesLinkUtility;
_setupInfo = setupInfo;
_securityContext = securityContext;
_crmSecurity = crmSecurity;
_tenantID = tenantManager.GetCurrentTenant().TenantId;
_settingsManager = settingsManager;
_configuration = configuration;
}
public void Update(T data, Expression <Func <Selector <T>, Selector <T> > > expression, UpdateAction action, Expression <Func <T, IList> > fields, bool immediately = true)
{
var t = ServiceProvider.GetService <T>();
if (!FactoryIndexerHelper.Support(t))
{
return;
}
try
{
var tenant = TenantManager.GetCurrentTenant().TenantId;
Indexer.Update(data, expression, tenant, action, fields, immediately);
}
catch (Exception e)
{
Logger.Error("Update", e);
}
}
public ProviderAccountDao(
IServiceProvider serviceProvider,
TenantUtil tenantUtil,
TenantManager tenantManager,
InstanceCrypto instanceCrypto,
SecurityContext securityContext,
ConsumerFactory consumerFactory,
DbContextManager <FilesDbContext> dbContextManager,
IOptionsMonitor <ILog> options)
{
TenantID = tenantManager.GetCurrentTenant().TenantId;
FilesDbContext = dbContextManager.Get(FileConstant.DatabaseId);
Logger = options.Get("ASC.Files");
ServiceProvider = serviceProvider;
TenantUtil = tenantUtil;
InstanceCrypto = instanceCrypto;
SecurityContext = securityContext;
ConsumerFactory = consumerFactory;
}
public object CreateUploadSession(T folderId, string fileName, long fileSize, string relativePath, bool encrypted)
{
var file = FileUploader.VerifyChunkedUpload(folderId, fileName, fileSize, FilesSettingsHelper.UpdateIfExist, relativePath);
if (FilesLinkUtility.IsLocalFileUploader)
{
var session = FileUploader.InitiateUpload(file.FolderID.ToString(), (file.ID ?? default).ToString(), file.Title, file.ContentLength, encrypted);
var response = ChunkedUploadSessionHelper.ToResponseObject(session, true);
return(new
{
success = true,
data = response
});
}
var createSessionUrl = FilesLinkUtility.GetInitiateUploadSessionUrl(TenantManager.GetCurrentTenant().TenantId, file.FolderID, file.ID, file.Title, file.ContentLength, encrypted, SecurityContext);
var request = (HttpWebRequest)WebRequest.Create(createSessionUrl);
request.Method = "POST";
request.ContentLength = 0;
// hack for uploader.onlyoffice.com in api requests
var rewriterHeader = ApiContext.HttpContext.Request.Headers[HttpRequestExtensions.UrlRewriterHeader];
if (!string.IsNullOrEmpty(rewriterHeader))
{
request.Headers[HttpRequestExtensions.UrlRewriterHeader] = rewriterHeader;
}
// hack. http://ubuntuforums.org/showthread.php?t=1841740
if (WorkContext.IsMono)
{
ServicePointManager.ServerCertificateValidationCallback += (s, ce, ca, p) => true;
}
using (var response = request.GetResponse())
using (var responseStream = response.GetResponseStream())
{
return(JObject.Parse(new StreamReader(responseStream).ReadToEnd())); //result is json string
}
}
/* public BaseCalendar ConvertCalendar(Ical.Net.Calendar calandarObj)
* {
* if (calandarObj == null) return null;
*
* var icalendar = new iCalendar(AuthContext, TimeZoneConverter, TenantManager);
* var result = new BusinessObjects.Calendar(AuthContext, TimeZoneConverter, icalendar, DataProvider);
*
* result.Name = string.IsNullOrEmpty(calandarObj.Name)
* ? calandarObj.Properties.ContainsKey("X-WR-CALNAME")
* ? calandarObj.Properties["X-WR-CALNAME"].Value.ToString()
* : string.Empty
* : calandarObj.Name;
*
* result.Description = calandarObj.Properties.ContainsKey("X-WR-CALDESC")
* ? calandarObj.Properties["X-WR-CALDESC"].Value.ToString()
* : string.Empty;
*
* var tzids = calandarObj.TimeZones.Select(x => x.TzId).Where(x => !string.IsNullOrEmpty(x)).ToList();
*
* result.TimeZone = tzids.Any()
* ? TimeZoneConverter.GetTimeZone(tzids.First())
* : (calandarObj.Properties.ContainsKey("X-WR-TIMEZONE")
* ? TimeZoneConverter.GetTimeZone(
* calandarObj.Properties["X-WR-TIMEZONE"].Value.ToString())
* : TimeZoneConverter.GetTimeZone(TenantManager.GetCurrentTenant().TimeZone));
*
* return result;
* }*/
public Ical.Net.Calendar ConvertCalendar(BaseCalendar calandarObj)
{
if (calandarObj == null)
{
return(null);
}
var result = new Ical.Net.Calendar();
result.Method = Ical.Net.CalendarMethods.Publish;
result.Scale = Ical.Net.CalendarScales.Gregorian;
result.Version = Ical.Net.LibraryMetadata.Version;
result.ProductId = "-//Ascensio System//OnlyOffice Calendar//EN";
if (!string.IsNullOrEmpty(calandarObj.Name))
{
result.AddProperty("X-WR-CALNAME", calandarObj.Name);
}
if (!string.IsNullOrEmpty(calandarObj.Description))
{
result.AddProperty("X-WR-CALDESC", calandarObj.Description);
}
if (calandarObj.TimeZone == null)
{
calandarObj.TimeZone = TimeZoneConverter.GetTimeZone(TenantManager.GetCurrentTenant().TimeZone);
}
var olsonTzId = TimeZoneConverter.WindowsTzId2OlsonTzId(calandarObj.TimeZone.Id);
var olsonTz = olsonTzId == calandarObj.TimeZone.Id
? calandarObj.TimeZone
: TimeZoneInfo.CreateCustomTimeZone(olsonTzId,
calandarObj.TimeZone.GetOffset(true),
calandarObj.TimeZone.DisplayName,
calandarObj.TimeZone.StandardName);
result.AddTimeZone(Ical.Net.CalendarComponents.VTimeZone.FromSystemTimeZone(olsonTz));
result.AddProperty("X-WR-TIMEZONE", olsonTzId);
return(result);
}
public static async Task <string> GeneratePromotion(ILog log, CouponManager couponManager, TenantManager tenantManager, int percent, int schedule)
{
try
{
var tenant = tenantManager.GetCurrentTenant();
var startDate = DateTime.UtcNow.Date;
var endDate = startDate.AddDays(schedule);
var code = tenant.TenantAlias;
var promotion = new Promotion
{
Type = "REGULAR",
Enabled = true,
MaximumOrdersNumber = 1,
InstantDiscount = false,
ChannelType = "ECOMMERCE",
ApplyRecurring = "NONE",
PublishToAffiliatesNetwork = 0,
AutoApply = 0,
StartDate = startDate.ToString("yyyy-MM-dd"),
EndDate = endDate.ToString("yyyy-MM-dd"),
Name = string.Format("{0} {1}% off", code, percent),
Coupon = new Coupon {
Type = "SINGLE", Code = code
},
Discount = new Discount {
Type = "PERCENT", Value = percent
},
Products = (await couponManager.GetProducts()).Select(r => new CouponProduct {
Code = r.ProductCode
})
};
return(JsonConvert.SerializeObject(promotion));
}
catch (Exception ex)
{
log.Error(ex.Message, ex);
throw;
}
}
public void Delete(Expression <Func <Selector <T>, Selector <T> > > expression, bool immediately = true)
{
var t = ServiceProvider.GetService <T>();
if (!FactoryIndexerHelper.Support(t))
{
return;
}
var tenant = TenantManager.GetCurrentTenant().TenantId;
try
{
Indexer.Delete(expression, tenant, immediately);
}
catch (Exception e)
{
Logger.Error("Index", e);
}
}
public void CreateSchedule(BackupStorageType storageType, Dictionary <string, string> storageParams, int backupsStored, CronParams cronParams, bool backupMail)
{
DemandPermissionsBackup();
DemandSize();
if (!SetupInfo.IsVisibleSettings("AutoBackup"))
{
throw new InvalidOperationException(Resource.ErrorNotAllowedOption);
}
ValidateCronSettings(cronParams);
var scheduleRequest = new CreateScheduleRequest
{
TenantId = TenantManager.GetCurrentTenant().TenantId,
BackupMail = backupMail,
Cron = cronParams.ToString(),
NumberOfBackupsStored = backupsStored,
StorageType = storageType,
StorageParams = storageParams
};
switch (storageType)
{
case BackupStorageType.ThridpartyDocuments:
case BackupStorageType.Documents:
scheduleRequest.StorageBasePath = storageParams["folderId"];
break;
case BackupStorageType.Local:
if (!CoreBaseSettings.Standalone)
{
throw new Exception("Access denied");
}
scheduleRequest.StorageBasePath = storageParams["filePath"];
break;
}
BackupService.CreateSchedule(scheduleRequest);
}
public AuthenticationTokenData AuthenticateMe([FromBody] AuthModel auth)
{
var tenant = TenantManager.GetCurrentTenant();
var user = GetUser(tenant.TenantId, auth.UserName, auth.Password);
try
{
var token = SecurityContext.AuthenticateMe(user.ID);
CookiesManager.SetCookies(CookiesType.AuthKey, token);
var expires = TenantCookieSettingsHelper.GetExpiresTime(tenant.TenantId);
return(new AuthenticationTokenData
{
Token = token,
Expires = expires
});
}
catch
{
throw new Exception("User authentication failed");
}
}
public void SendInstallInfo(UserInfo user)
{
try
{
StudioNotifyService.SendRegData(user);
var url = Configuration["web:install-url"];
if (string.IsNullOrEmpty(url))
{
return;
}
var tenant = TenantManager.GetCurrentTenant();
var q = new MailQuery
{
Email = user.Email,
Id = CoreSettings.GetKey(tenant.TenantId),
Alias = tenant.GetTenantDomain(CoreSettings),
};
var index = url.IndexOf("?v=", StringComparison.InvariantCultureIgnoreCase);
if (0 < index)
{
q.Version = url.Substring(index + 3) + Environment.OSVersion;
url = url.Substring(0, index);
}
using var webClient = new WebClient();
var values = new NameValueCollection
{
{ "query", Signature.Create(q, "4be71393-0c90-41bf-b641-a8d9523fba5c") }
};
webClient.UploadValues(url, values);
}
catch (Exception error)
{
Log.Error(error);
}
}
public IRecipient[] RecipientFromEmail(List <string> emails, bool checkActivation)
{
var res = new List <IRecipient>();
if (emails == null)
{
return(res.ToArray());
}
res.AddRange(emails.
Select(email => email.ToLower()).
Select(e => new DirectRecipient(e, null, new[] { e }, checkActivation)));
if (!checkActivation &&
CountMailsToNotActivated > 0 &&
TenantExtra.Saas && !CoreBaseSettings.Personal)
{
var tenant = TenantManager.GetCurrentTenant();
var tariff = TenantManager.GetTenantQuota(tenant.TenantId);
if (tariff.Free || tariff.Trial)
{
var spamEmailSettings = SettingsManager.Load <SpamEmailSettings>();
var sended = spamEmailSettings.MailsSended;
var mayTake = Math.Max(0, CountMailsToNotActivated - sended);
var tryCount = res.Count();
if (mayTake < tryCount)
{
res = res.Take(mayTake).ToList();
Log.Warn(string.Format("Free tenant {0} for today is trying to send {1} more letters without checking activation. Sent {2}", tenant.TenantId, tryCount, mayTake));
}
spamEmailSettings.MailsSended = sended + tryCount;
SettingsManager.Save(spamEmailSettings);
}
}
return(res.ToArray());
}
public void SetLogo(TenantWhiteLabelSettings tenantWhiteLabelSettings, WhiteLabelLogoTypeEnum type, string logoFileExt, byte[] data)
{
var store = StorageFactory.GetStorage(TenantManager.GetCurrentTenant().TenantId.ToString(), moduleName);
#region delete from storage if already exists
var isAlreadyHaveBeenChanged = !tenantWhiteLabelSettings.GetIsDefault(type);
if (isAlreadyHaveBeenChanged)
{
try
{
DeleteLogoFromStore(tenantWhiteLabelSettings, store, type);
}
catch (Exception e)
{
Log.Error(e);
}
}
#endregion
using (var memory = new MemoryStream(data))
using (var image = Image.FromStream(memory))
{
var logoSize = image.Size;
var logoFileName = BuildLogoFileName(type, logoFileExt, false);
memory.Seek(0, SeekOrigin.Begin);
store.Save(logoFileName, memory);
}
tenantWhiteLabelSettings.SetExt(type, logoFileExt);
tenantWhiteLabelSettings.SetIsDefault(type, false);
var generalSize = GetSize(type, true);
var generalFileName = BuildLogoFileName(type, logoFileExt, true);
ResizeLogo(type, generalFileName, data, -1, generalSize, store);
}
public object CreateLoginHistoryReport()
{
PermissionContext.DemandPermissions(SecutiryConstants.EditPortalSettings);
var tenantId = TenantManager.GetCurrentTenant().TenantId;
if (!SetupInfo.IsVisibleSettings(ManagementType.LoginHistory.ToString()) || CoreBaseSettings.Standalone && !TenantExtra.GetTenantQuota().Audit)
{
throw new BillingException(Resource.ErrorNotAllowedOption, "Audit");
}
var settings = SettingsManager.LoadForTenant <TenantAuditSettings>(TenantManager.GetCurrentTenant().TenantId);
var to = DateTime.UtcNow;
var from = to.Subtract(TimeSpan.FromDays(settings.LoginHistoryLifeTime));
var reportName = string.Format(AuditReportResource.LoginHistoryReportName + ".csv", from.ToString("MM.dd.yyyy"), to.ToString("MM.dd.yyyy"));
var events = LoginEventsRepository.Get(tenantId, from, to);
var result = AuditReportCreator.CreateCsvReport(events, reportName);
MessageService.Send(MessageAction.LoginHistoryReportDownloaded);
return(result);
}
private string Get(string name)
{
string value = null;
if (!OnlyDefault && CanSet)
{
var tenant = CoreBaseSettings.Standalone
? Tenant.DEFAULT_TENANT
: TenantManager.GetCurrentTenant().TenantId;
value = CoreSettings.GetSetting(GetSettingsKey(name), tenant);
}
if (string.IsNullOrEmpty(value))
{
if (AllProps.ContainsKey(name))
{
value = AllProps[name];
}
}
return(value);
}
public void DeleteLogo(string logoPath)
{
if (string.IsNullOrEmpty(logoPath))
{
return;
}
try
{
var store = StorageFactory.GetStorage(TenantManager.GetCurrentTenant().TenantId.ToString(CultureInfo.InvariantCulture), StorageName);
var fileName = Path.GetFileName(logoPath);
if (store.IsFile(fileName))
{
store.Delete(fileName);
}
}
catch (Exception e)
{
Log.Error(e);
}
}
new ConcurrentDictionary <string, object>(); /*Use SYNCHRONIZED for cross thread blocks*/
public object GetFolderMy(FileMarker fileMarker, IDaoFactory daoFactory)
{
if (!AuthContext.IsAuthenticated)
{
return(0);
}
if (UserManager.GetUsers(AuthContext.CurrentAccount.ID).IsVisitor(UserManager))
{
return(0);
}
var cacheKey = string.Format("my/{0}/{1}", TenantManager.GetCurrentTenant().TenantId, AuthContext.CurrentAccount.ID);
if (!UserRootFolderCache.TryGetValue(cacheKey, out var myFolderId))
{
myFolderId = GetFolderIdAndProccessFirstVisit(fileMarker, daoFactory, true);
if (!Equals(myFolderId, 0))
{
UserRootFolderCache[cacheKey] = myFolderId;
}
}
return(myFolderId);
}
new ConcurrentDictionary <int, object>(); /*Use SYNCHRONIZED for cross thread blocks*/
public object GetFolderShare(IFolderDao folderDao)
{
if (CoreBaseSettings.Personal)
{
return(null);
}
if (IsOutsider)
{
return(null);
}
if (!ShareFolderCache.TryGetValue(TenantManager.GetCurrentTenant().TenantId, out var sharedFolderId))
{
sharedFolderId = folderDao.GetFolderIDShare(true);
if (!sharedFolderId.Equals(0))
{
ShareFolderCache[TenantManager.GetCurrentTenant().TenantId] = sharedFolderId;
}
}
return(sharedFolderId);
}
new ConcurrentDictionary <int, object>(); /*Use SYNCHRONIZED for cross thread blocks*/
public object GetFolderProjects(IDaoFactory daoFactory)
{
if (CoreBaseSettings.Personal)
{
return(null);
}
if (WebItemManager[WebItemManager.ProjectsProductID].IsDisabled(WebItemSecurity, AuthContext))
{
return(null);
}
var folderDao = daoFactory.FolderDao;
if (!ProjectsRootFolderCache.TryGetValue(TenantManager.GetCurrentTenant().TenantId, out var result))
{
result = folderDao.GetFolderIDProjects(true);
ProjectsRootFolderCache[TenantManager.GetCurrentTenant().TenantId] = result;
}
return(result);
}
private ValidationResult ValidateEmailKeyInternal(string email, string key, TimeSpan validInterval)
{
if (string.IsNullOrEmpty(email))
{
throw new ArgumentNullException("email");
}
if (key == null)
{
throw new ArgumentNullException("key");
}
email = FormatEmail(TenantManager.GetCurrentTenant().TenantId, email);
var parts = key.Split(new[] { '.' }, StringSplitOptions.RemoveEmptyEntries);
if (parts.Length != 2)
{
return(ValidationResult.Invalid);
}
if (!long.TryParse(parts[0], out var ms))
{
return(ValidationResult.Invalid);
}
var hash = GetMashineHashedData(BitConverter.GetBytes(ms), Encoding.ASCII.GetBytes(email));
var key2 = DoStringFromBytes(hash);
var key2_good = string.Compare(parts[1], key2, StringComparison.InvariantCultureIgnoreCase) == 0;
if (!key2_good)
{
return(ValidationResult.Invalid);
}
var ms_current = (long)(DateTime.UtcNow - _from).TotalMilliseconds;
return(validInterval >= TimeSpan.FromMilliseconds(ms_current - ms) ? ValidationResult.Ok : ValidationResult.Expired);
}
public async Task Invoke(HttpContext context, UserManager userManager, TenantManager tenantManager, AuthContext authContext)
{
CultureInfo culture = null;
if (authContext.IsAuthenticated)
{
var user = userManager.GetUsers(authContext.CurrentAccount.ID);
if (!string.IsNullOrEmpty(user.CultureName))
{
culture = user.GetCulture();
}
}
if (culture == null)
{
culture = tenantManager.GetCurrentTenant().GetCulture();
}
Thread.CurrentThread.CurrentCulture = culture;
Thread.CurrentThread.CurrentUICulture = culture;
await next.Invoke(context);
}
public async Task UploadDir(string relativePath, string mappedPath)
{
if (!CanUpload())
{
return;
}
if (!Directory.Exists(mappedPath))
{
return;
}
var tenant = TenantManager.GetCurrentTenant();
var key = typeof(UploadOperationProgress).FullName + tenant.TenantId;
UploadOperationProgress uploadOperation;
lock (Locker)
{
uploadOperation = Cache.Get <UploadOperationProgress>(key);
if (uploadOperation != null)
{
return;
}
uploadOperation = new UploadOperationProgress(this, relativePath, mappedPath);
Cache.Insert(key, uploadOperation, DateTime.MaxValue);
}
tenant.SetStatus(TenantStatus.Migrating);
TenantManager.SaveTenant(tenant);
await uploadOperation.RunJobAsync();
tenant.SetStatus(Core.Tenants.TenantStatus.Active);
TenantManager.SaveTenant(tenant);
}
public string UploadFile(string relativePath, string mappedPath, Action <string> onComplete = null)
{
if (TokenSource.Token.IsCancellationRequested)
{
return(null);
}
if (!CanUpload())
{
return(null);
}
if (!File.Exists(mappedPath))
{
return(null);
}
var tenantId = TenantManager.GetCurrentTenant().TenantId;
UploadOperation uploadOperation;
var key = GetCacheKey(tenantId.ToString(), relativePath);
lock (Locker)
{
uploadOperation = Cache.Get <UploadOperation>(key);
if (uploadOperation != null)
{
return(!string.IsNullOrEmpty(uploadOperation.Result) ? uploadOperation.Result : string.Empty);
}
uploadOperation = new UploadOperation(ServiceProvider, tenantId, relativePath, mappedPath);
Cache.Insert(key, uploadOperation, DateTime.MaxValue);
}
uploadOperation.DoJob();
onComplete?.Invoke(uploadOperation.Result);
return(uploadOperation.Result);
}
