protected virtual async Task BuildStoreProductViewsAsync(Guid storeId)
{
var products = await _productRepository.GetListAsync(x => x.StoreId == storeId, true);
using var uow = UnitOfWorkManager.Begin(true, true);
await _repository.DeleteAsync(x => x.StoreId == storeId, true);
foreach (var product in products)
{
var productView = ObjectMapper.Map <Product, ProductView>(product);
await FillPriceInfoWithRealPriceAsync(product, productView);
await _repository.InsertAsync(productView);
}
await uow.SaveChangesAsync();
await uow.CompleteAsync();
await _cache.SetAsync(await GetCacheKeyAsync(storeId), new ProductViewCacheItem(),
new DistributedCacheEntryOptions
{
AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(Convert.ToInt32(
await SettingProvider.GetOrNullAsync(ProductsSettings.ProductView.CacheDurationSeconds)))
});
}
public virtual async Task SendChangePhoneNumberCodeAsync(SendChangePhoneNumberCodeDto input)
{
var securityTokenCacheKey = SmsSecurityTokenCacheItem.CalculateCacheKey(input.NewPhoneNumber, "SmsChangePhoneNumber");
var securityTokenCacheItem = await SecurityTokenCache.GetAsync(securityTokenCacheKey);
var interval = await SettingProvider.GetAsync(Settings.IdentitySettingNames.User.SmsRepetInterval, 1);
if (securityTokenCacheItem != null)
{
throw new UserFriendlyException(L["SendRepeatPhoneVerifyCode", interval]);
}
// 是否已有用户使用手机号绑定
if (await UserRepository.IsPhoneNumberConfirmedAsync(input.NewPhoneNumber))
{
throw new BusinessException(IdentityErrorCodes.DuplicatePhoneNumber);
}
var user = await UserManager.GetByIdAsync(CurrentUser.GetId());
var template = await SettingProvider.GetOrNullAsync(Settings.IdentitySettingNames.User.SmsPhoneNumberConfirmed);
var token = await UserManager.GenerateChangePhoneNumberTokenAsync(user, input.NewPhoneNumber);
// 发送验证码
await SecurityCodeSender.SendPhoneConfirmedCodeAsync(input.NewPhoneNumber, token, template);
securityTokenCacheItem = new SmsSecurityTokenCacheItem(token, user.ConcurrencyStamp);
await SecurityTokenCache
.SetAsync(securityTokenCacheKey, securityTokenCacheItem,
new DistributedCacheEntryOptions
{
AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(interval)
});
}
public virtual async Task <EmailSettingsDto> GetAsync()
{
await CheckFeatureAsync();
var settingsDto = new EmailSettingsDto
{
SmtpHost = await SettingProvider.GetOrNullAsync(EmailSettingNames.Smtp.Host),
SmtpPort = Convert.ToInt32(await SettingProvider.GetOrNullAsync(EmailSettingNames.Smtp.Port)),
SmtpUserName = await SettingProvider.GetOrNullAsync(EmailSettingNames.Smtp.UserName),
SmtpPassword = await SettingProvider.GetOrNullAsync(EmailSettingNames.Smtp.Password),
SmtpDomain = await SettingProvider.GetOrNullAsync(EmailSettingNames.Smtp.Domain),
SmtpEnableSsl = Convert.ToBoolean(await SettingProvider.GetOrNullAsync(EmailSettingNames.Smtp.EnableSsl)),
SmtpUseDefaultCredentials = Convert.ToBoolean(await SettingProvider.GetOrNullAsync(EmailSettingNames.Smtp.UseDefaultCredentials)),
DefaultFromAddress = await SettingProvider.GetOrNullAsync(EmailSettingNames.DefaultFromAddress),
DefaultFromDisplayName = await SettingProvider.GetOrNullAsync(EmailSettingNames.DefaultFromDisplayName),
};
if (CurrentTenant.IsAvailable)
{
settingsDto.SmtpHost = await SettingManager.GetOrNullForTenantAsync(EmailSettingNames.Smtp.Host, CurrentTenant.GetId(), false);
settingsDto.SmtpUserName = await SettingManager.GetOrNullForTenantAsync(EmailSettingNames.Smtp.UserName, CurrentTenant.GetId(), false);
settingsDto.SmtpPassword = await SettingManager.GetOrNullForTenantAsync(EmailSettingNames.Smtp.Password, CurrentTenant.GetId(), false);
settingsDto.SmtpDomain = await SettingManager.GetOrNullForTenantAsync(EmailSettingNames.Smtp.Domain, CurrentTenant.GetId(), false);
}
return(settingsDto);
}
public virtual async Task OnGetAsync(Guid storeId, Guid?categoryId)
{
ProductGroups =
(await _service.GetProductGroupListAsync()).Items
.Select(dto => new SelectListItem(dto.DisplayName, dto.Name)).ToList();
Categories =
(await _categoryAppService.GetListAsync(new GetCategoryListDto
{
MaxResultCount = LimitedResultRequestDto.MaxMaxResultCount
}))?.Items
.Select(dto => new SelectListItem(dto.DisplayName, dto.Id.ToString())).ToList();
Product = new CreateEditProductViewModel
{
StoreId = storeId,
ProductDetail = new CreateEditProductDetailViewModel
{
StoreId = storeId
}
};
if (categoryId.HasValue)
{
Product.CategoryIds = new List <Guid>(new[] { categoryId.Value });
}
var paymentExpireInString =
await SettingProvider.GetOrNullAsync(ProductsConsts.DefaultPaymentExpireInSettingName);
Product.PaymentExpireIn =
!paymentExpireInString.IsNullOrEmpty() ? TimeSpan.Parse(paymentExpireInString) : null;
}
public virtual async Task SendPhoneRegisterCodeAsync(SendPhoneRegisterCodeDto input)
{
await CheckSelfRegistrationAsync();
await CheckNewUserPhoneNumberNotBeUsedAsync(input.PhoneNumber);
var securityTokenCacheKey = SmsSecurityTokenCacheItem.CalculateCacheKey(input.PhoneNumber, "SmsVerifyCode");
var securityTokenCacheItem = await SecurityTokenCache.GetAsync(securityTokenCacheKey);
var interval = await SettingProvider.GetAsync(IdentitySettingNames.User.SmsRepetInterval, 1);
if (securityTokenCacheItem != null)
{
throw new UserFriendlyException(L["SendRepeatSmsVerifyCode", interval]);
}
var template = await SettingProvider.GetOrNullAsync(IdentitySettingNames.User.SmsNewUserRegister);
// 安全令牌
var securityToken = GuidGenerator.Create().ToString("N");
var code = TotpService.GenerateCode(Encoding.Unicode.GetBytes(securityToken), securityTokenCacheKey);
securityTokenCacheItem = new SmsSecurityTokenCacheItem(code.ToString(), securityToken);
await SecurityCodeSender.SendPhoneConfirmedCodeAsync(
input.PhoneNumber, securityTokenCacheItem.Token, template);
await SecurityTokenCache
.SetAsync(securityTokenCacheKey, securityTokenCacheItem,
new DistributedCacheEntryOptions
{
AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(interval)
});
}
public virtual async Task <GetPcLoginACodeOutput> GetPcLoginACodeAsync(string miniProgramName)
{
var miniProgram = await _miniProgramRepository.GetAsync(x => x.Name == miniProgramName);
var options = new AbpWeChatMiniProgramOptions
{
OpenAppId = miniProgram.OpenAppIdOrName,
AppId = miniProgram.AppId,
AppSecret = miniProgram.AppSecret,
EncodingAesKey = miniProgram.EncodingAesKey,
Token = miniProgram.Token
};
using (_weChatMiniProgramAsyncLocal.Change(options))
{
var token = Guid.NewGuid().ToString("N");
var handlePage = await SettingProvider.GetOrNullAsync(MiniProgramsSettings.PcLogin.HandlePage);
var aCodeResponse = await _aCodeService.GetUnlimitedACodeAsync(token, handlePage);
if (aCodeResponse.ErrorCode != 0)
{
throw new WeChatBusinessException(aCodeResponse.ErrorCode, aCodeResponse.ErrorMessage);
}
return(new GetPcLoginACodeOutput
{
Token = token,
ACode = aCodeResponse.BinaryData
});
}
}
public virtual async Task SendPhoneSigninCodeAsync(SendPhoneSigninCodeDto input)
{
var securityTokenCacheKey = SmsSecurityTokenCacheItem.CalculateCacheKey(input.PhoneNumber, "SmsVerifyCode");
var securityTokenCacheItem = await SecurityTokenCache.GetAsync(securityTokenCacheKey);
var interval = await SettingProvider.GetAsync(IdentitySettingNames.User.SmsRepetInterval, 1);
if (securityTokenCacheItem != null)
{
throw new UserFriendlyException(L["SendRepeatSmsVerifyCode", interval]);
}
// 传递 isConfirmed 验证过的用户才允许通过手机登录
var user = await GetUserByPhoneNumberAsync(input.PhoneNumber, isConfirmed : true);
var code = await UserManager.GenerateTwoFactorTokenAsync(user, TokenOptions.DefaultPhoneProvider);
var template = await SettingProvider.GetOrNullAsync(IdentitySettingNames.User.SmsUserSignin);
// 发送登录验证码短信
await SecurityCodeSender.SendPhoneConfirmedCodeAsync(input.PhoneNumber, code, template);
// 缓存登录验证码状态,防止同一手机号重复发送
securityTokenCacheItem = new SmsSecurityTokenCacheItem(code, user.SecurityStamp);
await SecurityTokenCache
.SetAsync(securityTokenCacheKey, securityTokenCacheItem,
new DistributedCacheEntryOptions
{
AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(interval)
});
}
public async Task HandleEventAsync(CreateEventData eventData)
{
var userDefaultCultureName = await SettingProvider.GetOrNullAsync(LocalizationSettingNames.DefaultLanguage);
if (userDefaultCultureName.IsNullOrWhiteSpace())
{
userDefaultCultureName = CultureInfo.CurrentUICulture.Name;
}
// 使用系统区域语言发布通知
using (CultureHelper.Use(userDefaultCultureName, userDefaultCultureName))
{
var tenantAdminUserIdentifier = new UserIdentifier(eventData.AdminUserId, eventData.AdminEmailAddress);
var notificationData = new NotificationData();
notificationData.WriteStandardData(
L("NewTenantRegisteredNotificationTitle"),
L("NewTenantRegisteredNotificationMessage", eventData.Name),
DateTime.Now, eventData.AdminEmailAddress);
// 发布租户创建通知
await NotificationSender
.SendNofiterAsync(
TenantNotificationNames.NewTenantRegistered,
notificationData,
tenantAdminUserIdentifier,
eventData.Id,
NotificationSeverity.Success);
}
}
protected virtual async Task CheckFile(FileDto input)
{
if (input.Bytes.IsNullOrEmpty())
{
throw new AbpValidationException("Bytes can not be null or empty!",
new List <ValidationResult>
{
new ValidationResult("Bytes can not be null or empty!", new[] { "Bytes" })
});
}
var allowedMaxFileSize = await SettingProvider.GetAsync <int>(FileManagementSettings.AllowedMaxFileSize);//kb
var allowedUploadFormats = (await SettingProvider.GetOrNullAsync(FileManagementSettings.AllowedUploadFormats))
?.Split(",", StringSplitOptions.RemoveEmptyEntries);
if (input.Bytes.Length > allowedMaxFileSize * 1024)
{
throw new UserFriendlyException(L["FileManagement.ExceedsTheMaximumSize", allowedMaxFileSize]);
}
if (allowedUploadFormats == null || !allowedUploadFormats.Contains(Path.GetExtension(input.FileName)))
{
throw new UserFriendlyException(L["FileManagement.NotValidFormat"]);
}
}
protected virtual async Task BuildStoreProductViewsAsync(Guid storeId)
{
var resultDto = await _productAppService.GetListAsync(new GetProductListInput
{
StoreId = storeId
});
using var uow = UnitOfWorkManager.Begin(true, true);
await _repository.DeleteAsync(x => x.StoreId == storeId, true);
foreach (var product in resultDto.Items)
{
await _repository.InsertAsync(ObjectMapper.Map <ProductDto, ProductView>(product));
}
await uow.CompleteAsync();
await _cache.SetAsync(await GetCacheKeyAsync(storeId), new ProductViewCacheItem(),
new DistributedCacheEntryOptions
{
AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(Convert.ToInt32(
await SettingProvider.GetOrNullAsync(ProductsSettings.ProductView.CacheDurationSeconds)))
});
}
private async Task NormalizeMaxResultCountAsync(PagedAndSortedResultRequestDto input)
{
var maxPageSize = (await SettingProvider.GetOrNullAsync(ProductManagementSettings.MaxPageSize))?.To <int>();
if (maxPageSize.HasValue && input.MaxResultCount > maxPageSize.Value)
{
input.MaxResultCount = maxPageSize.Value;
}
}
public virtual async Task SendAsync(SmsMessage smsMessage)
{
var domain = await SettingProvider.GetOrNullAsync(AliyunSmsSettingNames.Sms.Domain);
var action = await SettingProvider.GetOrNullAsync(AliyunSmsSettingNames.Sms.ActionName);
var version = await SettingProvider.GetOrNullAsync(AliyunSmsSettingNames.Sms.Version);
Check.NotNullOrWhiteSpace(domain, AliyunSmsSettingNames.Sms.Domain);
Check.NotNullOrWhiteSpace(action, AliyunSmsSettingNames.Sms.ActionName);
Check.NotNullOrWhiteSpace(version, AliyunSmsSettingNames.Sms.Version);
CommonRequest request = new CommonRequest
{
Method = MethodType.POST,
Domain = domain,
Action = action,
Version = version
};
await TryAddTemplateCodeAsync(request, smsMessage);
await TryAddSignNameAsync(request, smsMessage);
await TryAddSendPhoneAsync(request, smsMessage);
TryAddTemplateParam(request, smsMessage);
try
{
var client = await AcsClientFactory.CreateAsync();
CommonResponse response = client.GetCommonResponse(request);
var responseContent = Encoding.Default.GetString(response.HttpResponse.Content);
var aliyunResponse = JsonSerializer.Deserialize <AliyunSmsResponse>(responseContent);
if (!aliyunResponse.IsSuccess())
{
if (await SettingProvider.IsTrueAsync(AliyunSmsSettingNames.Sms.VisableErrorToClient))
{
throw new UserFriendlyException(aliyunResponse.Code, aliyunResponse.Message);
}
throw new AliyunSmsException(aliyunResponse.Code, $"Text message sending failed, code:{aliyunResponse.Code}, message:{aliyunResponse.Message}!");
}
}
catch (ServerException se)
{
throw new AliyunSmsException(se.ErrorCode, $"Sending text messages to aliyun server is abnormal,type: {se.ErrorType}, error: {se.ErrorMessage}");
}
catch (ClientException ce)
{
throw new AliyunSmsException(ce.ErrorCode, $"A client exception occurred in sending SMS messages,type: {ce.ErrorType}, error: {ce.ErrorMessage}");
}
}
private async Task TryAddTemplateCodeAsync(CommonRequest request, SmsMessage smsMessage)
{
if (smsMessage.Properties.TryGetValue("TemplateCode", out object template) && template != null)
{
request.AddQueryParameters("TemplateCode", template.ToString());
smsMessage.Properties.Remove("TemplateCode");
}
else
{
var defaultTemplateCode = await SettingProvider.GetOrNullAsync(AliyunSmsSettingNames.Sms.DefaultTemplateCode);
Check.NotNullOrWhiteSpace(defaultTemplateCode, "TemplateCode");
request.AddQueryParameters("TemplateCode", defaultTemplateCode);
}
}
public virtual async Task SendPhoneResetPasswordCodeAsync(SendPhoneResetPasswordCodeDto input)
{
/*
* 注解: 微软的重置密码方法通过 UserManager.GeneratePasswordResetTokenAsync 接口生成密码重置Token
* 而这个Token设计的意义就是用户通过链接来重置密码,所以不适合短信验证
* 某些企业是把链接生成一个短链发送短信的,不过这种方式不是很推荐,因为现在是真没几个人敢随便点短信链接的
*
* 此处设计方式为:
*
* step1: 例行检查是否重复发送,这一点是很有必要的
* step2: 通过已确认的手机号来查询用户,如果用户未确认手机号,那就不能发送,这一点也是很有必要的
* step3(重点): 通过 UserManager.GenerateTwoFactorTokenAsync 接口来生成二次认证码,这就相当于伪验证码,只是用于确认用户传递的验证码是否通过
* 比起自己生成随机数,这个验证码利用了TOTP算法,有时间限制的
* step4(重点): 用户传递验证码后,通过 UserManager.VerifyTwoFactorTokenAsync 接口来校验验证码
* 验证通过后,再利用 UserManager.GeneratePasswordResetTokenAsync 接口来生成真正的用于重置密码的Token
*/
var securityTokenCacheKey = SmsSecurityTokenCacheItem.CalculateCacheKey(input.PhoneNumber, "SmsVerifyCode");
var securityTokenCacheItem = await SecurityTokenCache.GetAsync(securityTokenCacheKey);
var interval = await SettingProvider.GetAsync(IdentitySettingNames.User.SmsRepetInterval, 1);
// 传递 isConfirmed 用户必须是已确认过手机号的
var user = await GetUserByPhoneNumberAsync(input.PhoneNumber, isConfirmed : true);
// 能查询到缓存就是重复发送
if (securityTokenCacheItem != null)
{
throw new UserFriendlyException(L["SendRepeatSmsVerifyCode", interval]);
}
var template = await SettingProvider.GetOrNullAsync(IdentitySettingNames.User.SmsResetPassword);
// 生成二次认证码
var code = await UserManager.GenerateTwoFactorTokenAsync(user, TokenOptions.DefaultPhoneProvider);
// 发送短信验证码
await SecurityCodeSender.SendPhoneConfirmedCodeAsync(input.PhoneNumber, code, template);
// 缓存这个手机号的记录,防重复
securityTokenCacheItem = new SmsSecurityTokenCacheItem(code, user.SecurityStamp);
await SecurityTokenCache
.SetAsync(securityTokenCacheKey, securityTokenCacheItem,
new DistributedCacheEntryOptions
{
AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(interval)
});
}
protected virtual async Task <string> SendResetPasswordVerifyCodeAsync(string phoneNumber, string phoneVerifyCode)
{
// 查找用户信息
var user = await GetUserByPhoneNumberAsync(phoneNumber);
// 获取登录验证码模板号
var templateCode = await SettingProvider.GetOrNullAsync(AccountSettingNames.SmsResetPasswordTemplateCode);
// 生成重置密码验证码
var phoneVerifyToken = await UserManager.GeneratePasswordResetTokenAsync(user);
// 发送短信验证码
await SendPhoneVerifyMessageAsync(templateCode, user.PhoneNumber, phoneVerifyCode);
return(phoneVerifyToken);
}
/// <summary>
/// 发送登录验证码
/// </summary>
/// <param name="phoneNumber">手机号</param>
/// <returns>返回登录验证码</returns>
protected virtual async Task <string> SendSigninVerifyCodeAsync(string phoneNumber)
{
// 查找用户信息
var user = await GetUserByPhoneNumberAsync(phoneNumber);
// 获取登录验证码模板号
var templateCode = await SettingProvider.GetOrNullAsync(AccountSettingNames.SmsSigninTemplateCode);
// 生成手机验证码
var phoneVerifyCode = await PhoneNumberTokenProvider.GenerateAsync("phone_verify", UserManager, user);
// 发送短信验证码
await SendPhoneVerifyMessageAsync(templateCode, user.PhoneNumber, phoneVerifyCode);
return(phoneVerifyCode);
}
/// <summary>
/// 验证手机号码
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
/// <remarks>
/// 用户传递手机号码及认证类型
/// 1、如果认证类型为注册：
/// 先查询是否存在此手机号的缓存验证码信息,如果存在,抛出不能重复发送验证码异常
/// 随机生成6位纯数字验证码,通过短信接口服务发送到用户手机,并缓存验证码,设定一个有效时长
///
/// 2、如果认证类型为登录：
/// 先查询是否存在此手机号的缓存验证码信息,如果存在,抛出不能重复发送验证码异常
/// 通过手机号查询用户信息,如果用户不存在,抛出手机号未注册异常
/// 调用PhoneNumberTokenProvider接口生成6位手机验证码,用途为 phone_verify
/// 发送手机验证码到用户手机,并缓存验证码,设定一个有效时长
///
/// 用户调用 IdentityServer4/connect/token 登录系统（需要引用LINGYUN.Abp.IdentityServer.SmsValidator模块）
/// 参数1:grant_type=phone_verify
/// 参数2:phone_number=手机号码
/// 参数3:phone_verify_code=手机验证码
/// 参数4:client_id=客户端标识
/// 参数5:client_secret=客户端密钥
/// </remarks>
public virtual async Task VerifyPhoneNumberAsync(VerifyDto input)
{
var verifyCodeExpiration = await SettingProvider.GetAsync <int>(AccountSettingNames.PhoneVerifyCodeExpiration);
var phoneVerifyCacheKey = NormalizeCacheKey(input.PhoneNumber);
var verifyCacheItem = await Cache.GetAsync(phoneVerifyCacheKey);
if (verifyCacheItem != null)
{
throw new UserFriendlyException(L["PhoneVerifyCodeNotRepeatSend", verifyCodeExpiration]);
}
verifyCacheItem = new AccountRegisterVerifyCacheItem
{
PhoneNumber = input.PhoneNumber,
};
switch (input.VerifyType)
{
case PhoneNumberVerifyType.Register:
var phoneVerifyCode = new Random().Next(100000, 999999);
verifyCacheItem.VerifyCode = phoneVerifyCode.ToString();
var templateCode = await SettingProvider.GetOrNullAsync(AccountSettingNames.SmsRegisterTemplateCode);
await SendPhoneVerifyMessageAsync(templateCode, input.PhoneNumber, phoneVerifyCode.ToString());
return;
case PhoneNumberVerifyType.Signin:
var phoneSigninCode = await SendSigninVerifyCodeAsync(input.PhoneNumber);
verifyCacheItem.VerifyCode = phoneSigninCode;
break;
case PhoneNumberVerifyType.ResetPassword:
var resetPasswordCode = new Random().Next(100000, 999999);
verifyCacheItem.VerifyCode = resetPasswordCode.ToString();
var resetPasswordToken = await SendResetPasswordVerifyCodeAsync(input.PhoneNumber, verifyCacheItem.VerifyCode);
verifyCacheItem.VerifyToken = resetPasswordToken;
break;
}
var cacheOptions = new DistributedCacheEntryOptions
{
AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(verifyCodeExpiration)
};
await Cache.SetAsync(phoneVerifyCacheKey, verifyCacheItem, cacheOptions);
}
protected virtual async Task <AliyunBasicSessionCredentialsCacheItem> GetCacheItemAsync(string accessKeyId, string accessKeySecret, string regionId)
{
var cacheItem = await Cache.GetAsync(AliyunBasicSessionCredentialsCacheItem.CacheKey);
if (cacheItem == null)
{
var roleArn = await SettingProvider.GetOrNullAsync(AliyunSettingNames.Authorization.RamRoleArn);
var roleSession = await SettingProvider.GetOrNullAsync(AliyunSettingNames.Authorization.RoleSessionName);
Check.NotNullOrWhiteSpace(roleArn, AliyunSettingNames.Authorization.RamRoleArn);
var policy = await SettingProvider.GetOrNullAsync(AliyunSettingNames.Authorization.Policy);
var durationSeconds = await SettingProvider.GetAsync(AliyunSettingNames.Authorization.DurationSeconds, 3000);
var profile = DefaultProfile.GetProfile(regionId, accessKeyId, accessKeySecret);
var request = new AssumeRoleRequest
{
AcceptFormat = FormatType.JSON,
RoleArn = roleArn,
RoleSessionName = roleSession,
DurationSeconds = durationSeconds,
Policy = policy.IsNullOrWhiteSpace() ? null : policy
};
var client = new DefaultAcsClient(profile);
var response = client.GetAcsResponse(request);
cacheItem = new AliyunBasicSessionCredentialsCacheItem(
response.Credentials.AccessKeyId,
response.Credentials.AccessKeySecret,
response.Credentials.SecurityToken);
await Cache.SetAsync(
AliyunBasicSessionCredentialsCacheItem.CacheKey,
cacheItem,
new DistributedCacheEntryOptions
{
AbsoluteExpirationRelativeToNow = TimeSpan.FromSeconds(durationSeconds - 10)
});
}
return(cacheItem);
}
private async Task TryAddSendPhoneAsync(CommonRequest request, SmsMessage smsMessage)
{
if (smsMessage.PhoneNumber.IsNullOrWhiteSpace())
{
var defaultPhoneNumber = await SettingProvider.GetOrNullAsync(AliyunSmsSettingNames.Sms.DefaultPhoneNumber);
// check phone number length...
Check.NotNullOrWhiteSpace(
defaultPhoneNumber,
AliyunSmsSettingNames.Sms.DefaultPhoneNumber,
maxLength: 11, minLength: 11);
request.AddQueryParameters("PhoneNumbers", defaultPhoneNumber);
}
else
{
request.AddQueryParameters("PhoneNumbers", smsMessage.PhoneNumber);
}
}
public virtual async Task <OssObjectDto> CreateAsync(CreateOssObjectInput input)
{
if (!input.Content.IsNullOrEmpty())
{
// 检查文件大小
var fileSizeLimited = await SettingProvider
.GetAsync(
AbpOssManagementSettingNames.FileLimitLength,
AbpOssManagementSettingNames.DefaultFileLimitLength);
if (fileSizeLimited * 1024 * 1024 < input.Content.Length)
{
ThrowValidationException(L["UploadFileSizeBeyondLimit", fileSizeLimited], nameof(input.Content));
}
// 文件扩展名
var fileExtensionName = FileHelper.GetExtension(input.Object);
var fileAllowExtension = await SettingProvider.GetOrNullAsync(AbpOssManagementSettingNames.AllowFileExtensions);
// 检查文件扩展名
if (!fileAllowExtension.Split(',')
.Any(fe => fe.Equals(fileExtensionName, StringComparison.CurrentCultureIgnoreCase)))
{
ThrowValidationException(L["NotAllowedFileExtensionName", fileExtensionName], "FileName");
}
}
var oss = CreateOssContainer();
var createOssObjectRequest = new CreateOssObjectRequest(
input.Bucket,
input.Object,
input.Content,
input.Path,
input.ExpirationTime)
{
Overwrite = input.Overwrite
};
var ossObject = await oss.CreateObjectAsync(createOssObjectRequest);
return(ObjectMapper.Map <OssObject, OssObjectDto>(ossObject));
}
public async Task DeleteFileByDocumentIdAndFileNameAsync(DeleteFileByDocumentIdAndFileNameInput input)
{
var document = await DocumentRepository.GetAsync(input.Id);
if (document?.Id < 0)
{
throw new BusinessException(code: DocumentManagementErrorCodes.Document.CodeNotExists)
.WithData("Code", "Not Found");
}
if (!string.IsNullOrEmpty(document.FileName))
{
List <string> files = document.FileName.Split(';').ToList();
files.Remove(input.FileName);
document.FileName = string.Join(";", files);
document.LinkFile = string.Empty;
string uploadFolderPath = await SettingProvider.GetOrNullAsync(DocumentManagementSettings.UploadFilePath);
File.Delete($"{uploadFolderPath}/{document.FolderName}/{input.FileName}");
}
}
public virtual async Task <TClient> CreateAsync()
{
var regionId = await SettingProvider.GetOrNullAsync(AliyunSettingNames.Authorization.RegionId);
var accessKey = await SettingProvider.GetOrNullAsync(AliyunSettingNames.Authorization.AccessKeyId);
var accessKeySecret = await SettingProvider.GetOrNullAsync(AliyunSettingNames.Authorization.AccessKeySecret);
Check.NotNullOrWhiteSpace(regionId, AliyunSettingNames.Authorization.RegionId);
Check.NotNullOrWhiteSpace(accessKey, AliyunSettingNames.Authorization.AccessKeyId);
Check.NotNullOrWhiteSpace(accessKeySecret, AliyunSettingNames.Authorization.AccessKeySecret);
if (await SettingProvider.IsTrueAsync(AliyunSettingNames.Authorization.UseSecurityTokenService))
{
var cacheItem = await GetCacheItemAsync(accessKey, accessKeySecret, regionId);
return(GetSecurityTokenClient(regionId, cacheItem.AccessKeyId, cacheItem.AccessKeySecret, cacheItem.SecurityToken));
}
return(GetClient(regionId, accessKey, accessKeySecret));
}
public virtual async Task <string> CreateAsync(FileUploadInputDto input)
{
if (input.Bytes.IsNullOrEmpty())
{
throw new AbpValidationException("Bytes can not be null or empty!",
new List <ValidationResult>
{
new ValidationResult("Bytes can not be null or empty!", new[] { "Bytes" })
});
}
var allowedMaxFileSize = await SettingProvider.GetAsync <int>(FileManagementSettings.AllowedMaxFileSize);//kb
var allowedUploadFormats = (await SettingProvider.GetOrNullAsync(FileManagementSettings.AllowedUploadFormats))
?.Split(",", StringSplitOptions.RemoveEmptyEntries);
if (input.Bytes.Length > allowedMaxFileSize * 1024)
{
throw new UserFriendlyException(L["FileManagement.ExceedsTheMaximumSize", allowedMaxFileSize]);
}
if (allowedUploadFormats == null || !allowedUploadFormats.Contains(Path.GetExtension(input.Name)))
{
throw new UserFriendlyException(L["FileManagement.NotValidFormat"]);
}
var fileName = Guid.NewGuid().ToString("N") + Path.GetExtension(input.Name);
var filePath = Path.Combine(FileOptions.FileUploadLocalFolder, fileName);
if (!Directory.Exists(FileOptions.FileUploadLocalFolder))
{
Directory.CreateDirectory(FileOptions.FileUploadLocalFolder);
}
File.WriteAllBytes(filePath, input.Bytes);
return(fileName);
}
public virtual async Task AppendFileAsync([FromQuery] VersionFileCreateDto versionFileCreate)
{
// 检查文件大小
var fileSizeLimited = await SettingProvider
.GetAsync(PlatformSettingNames.AppVersion.VersionFileLimitLength, AppVersionConsts.DefaultVersionFileLimitLength);
if (fileSizeLimited * 1024 * 1024 < versionFileCreate.TotalByte)
{
throw new UserFriendlyException(L["UploadFileSizeBeyondLimit", fileSizeLimited]);
}
// 采用分块模式上传文件
// 保存分块到临时目录
var fileName = versionFileCreate.FileName;
// 文件扩展名
var fileExtensionName = FileHelper.GetExtension(fileName);
var fileAllowExtension = await SettingProvider
.GetOrNullAsync(PlatformSettingNames.AppVersion.AllowVersionFileExtensions);
if (fileAllowExtension.IsNullOrWhiteSpace())
{
fileAllowExtension = AppVersionConsts.DefaultAllowVersionFileExtensions;
}
// 检查文件扩展名
if (!fileAllowExtension.Split(',').Any(fe => fe.Equals(fileExtensionName, StringComparison.CurrentCultureIgnoreCase)))
{
throw new UserFriendlyException(L["NotAllowedFileExtensionName", fileExtensionName]);
}
// 当前计算机临时目录
var tempFilePath = Environment.GetFolderPath(Environment.SpecialFolder.Templates);
// 以上传的文件名创建一个临时目录
tempFilePath = Path.Combine(tempFilePath, "lingyun-platform", Path.GetFileNameWithoutExtension(fileName));
// 以上传的分片索引创建临时文件
var tempSavedFile = Path.Combine(tempFilePath, $"{versionFileCreate.CurrentByte}.{fileExtensionName}");
if (!Directory.Exists(tempFilePath))
{
// 临时目录不存在则创建
Directory.CreateDirectory(tempFilePath);
}
try
{
if (HttpContext.RequestAborted.IsCancellationRequested)
{
// 如果取消请求,删除临时目录
Directory.Delete(tempFilePath, true);
return;
}
// 保存临时文件
using (var fs = new FileStream(tempSavedFile, FileMode.Create, FileAccess.Write))
{
// 写入当前分片文件
await Request.Body.CopyToAsync(fs);
}
if (versionFileCreate.CurrentByte == versionFileCreate.TotalByte)
{
// 合并文件
var mergeSavedFile = Path.Combine(tempFilePath, $"{fileName}");
// 获取并排序所有分片文件
var mergeFiles = Directory.GetFiles(tempFilePath).OrderBy(f => f.Length).ThenBy(f => f);
// 创建临时合并文件
using (var mergeSavedFileStream = new FileStream(mergeSavedFile, FileMode.Create))
{
foreach (var mergeFile in mergeFiles)
{
// 读取当前文件字节
var mergeFileBytes = await FileHelper.ReadAllBytesAsync(mergeFile);
// 写入到合并文件流
await mergeSavedFileStream.WriteAsync(mergeFileBytes, 0, mergeFileBytes.Length);
// 删除已参与合并的临时文件分片
FileHelper.DeleteIfExists(mergeFile);
}
// 上传最终合并的文件并取得SHA256指纹
var fileData = await mergeSavedFileStream.GetAllBytesAsync();
versionFileCreate.SHA256 = await _versionFileManager.SaveFileAsync(versionFileCreate.Version,
versionFileCreate.FilePath, versionFileCreate.FileName, versionFileCreate.FileVersion, fileData);
}
// 添加到版本信息
await _versionAppService.AppendFileAsync(versionFileCreate);
// 文件保存之后删除临时文件目录
Directory.Delete(tempFilePath, true);
}
}
catch
{
// 发生异常删除临时文件目录
Directory.Delete(tempFilePath, true);
throw;
}
}
/// <summary>
/// 获取更新的时间戳, 用于播放时进行比较
/// </summary>
/// <returns></returns>
public async Task <int> GetUpdatedTimeStampAsync()
{
return(int.Parse(await SettingProvider.GetOrNullAsync(CMSSettings.AnnouncementUpdatedTimeStamp)));
}
public Task <string> GetDomainAsync()
{
return(SettingProvider.GetOrNullAsync(EmailSettingNames.Smtp.Domain));
}
public virtual async Task CreateFileAsync([FromForm] FileUploadDto input)
{
// 检查文件大小
var fileSizeLimited = await SettingProvider
.GetAsync(
AbpFileManagementSettingNames.FileLimitLength,
AbpFileManagementSettingNames.DefaultFileLimitLength);
if (fileSizeLimited * 1024 * 1024 < input.TotalSize)
{
throw new UserFriendlyException(L["UploadFileSizeBeyondLimit", fileSizeLimited]);
}
// 采用分块模式上传文件
// 保存分块到临时目录
var fileName = input.FileName;
// 文件扩展名
var fileExtensionName = FileHelper.GetExtension(fileName);
var fileAllowExtension = await SettingProvider
.GetOrNullAsync(AbpFileManagementSettingNames.AllowFileExtensions);
if (fileAllowExtension.IsNullOrWhiteSpace())
{
fileAllowExtension = AbpFileManagementSettingNames.DefaultAllowFileExtensions;
}
// 检查文件扩展名
if (!fileAllowExtension.Split(',')
.Any(fe => fe.Equals(fileExtensionName, StringComparison.CurrentCultureIgnoreCase)))
{
throw new UserFriendlyException(L["NotAllowedFileExtensionName", fileExtensionName]);
}
// 以上传的文件名创建一个临时目录
var tempFilePath = Path.Combine(
Path.GetTempPath(),
"lingyun-abp-file-management",
"upload",
string.Concat(input.Path ?? "", input.FileName).ToMd5());
DirectoryHelper.CreateIfNotExists(tempFilePath);
// 以上传的分片索引创建临时文件
var tempSavedFile = Path.Combine(tempFilePath, $"{input.ChunkNumber}.{fileExtensionName}");
try
{
if (HttpContext.RequestAborted.IsCancellationRequested)
{
// 如果取消请求,删除临时目录
Directory.Delete(tempFilePath, true);
return;
}
if (input.File != null)
{
// 保存临时文件
using (var fs = new FileStream(tempSavedFile, FileMode.Create, FileAccess.Write))
{
// 写入当前分片文件
await input.File.CopyToAsync(fs);
}
}
if (input.ChunkNumber == input.TotalChunks)
{
// 合并文件
var mergeSavedFile = Path.Combine(tempFilePath, $"{fileName}");
// 获取并排序所有分片文件
var mergeFiles = Directory.GetFiles(tempFilePath).OrderBy(f => f.Length).ThenBy(f => f);
// 创建临时合并文件
input.Data = new byte[0];
foreach (var mergeFile in mergeFiles)
{
// 读取当前文件字节
var mergeFileBytes = await FileHelper.ReadAllBytesAsync(mergeFile);
// 写入到合并文件流
input.Data = input.Data.Concat(mergeFileBytes).ToArray();
Array.Clear(mergeFileBytes, 0, mergeFileBytes.Length);
// 删除已参与合并的临时文件分片
FileHelper.DeleteIfExists(mergeFile);
}
await FileSystemAppService.CreateFileAsync(input);
// 文件保存之后删除临时文件目录
Directory.Delete(tempFilePath, true);
}
}
catch
{
// 发生异常删除临时文件目录
Directory.Delete(tempFilePath, true);
throw;
}
}
public override async Task <IActionResult> OnGetAsync()
{
MiniProgramName ??= await SettingProvider.GetOrNullAsync(MiniProgramsSettings.PcLogin.DefaultProgramName);
return(await base.OnGetAsync());
}
public virtual async Task <IActionResult> OnPostAsync()
{
var user = await SignInManager.GetTwoFactorAuthenticationUserAsync();
if (user == null)
{
Alerts.Warning(L["TwoFactorAuthenticationInvaidUser"]);
return(Page());
}
if (Input.SelectedProvider == "Authenticator")
{
// 用户通过邮件/短信链接进入授权页面
return(RedirectToPage("VerifyAuthenticatorCode", new
{
returnUrl = ReturnUrl,
returnUrlHash = ReturnUrlHash,
rememberMe = RememberMe
}));
}
// 生成验证码
var code = await UserManager.GenerateTwoFactorTokenAsync(user, Input.SelectedProvider);
if (string.IsNullOrWhiteSpace(code))
{
Alerts.Warning(L["InvaidGenerateTwoFactorToken"]);
return(Page());
}
if (Input.SelectedProvider == "Email")
{
var appName = "MVC"; // TODO: 跟随Abp框架的意思变动
await AccountEmailVerifySender
.SendMailLoginVerifyLinkAsync(
user, code, appName,
Input.SelectedProvider,
RememberMe, ReturnUrl, ReturnUrlHash);
}
else if (Input.SelectedProvider == "Phone")
{
var phoneNumber = await UserManager.GetPhoneNumberAsync(user);
var templateCode = await SettingProvider.GetOrNullAsync(AccountSettingNames.SmsSigninTemplateCode);
Check.NotNullOrWhiteSpace(templateCode, nameof(AccountSettingNames.SmsSigninTemplateCode));
// TODO: 以后扩展短信模板发送
var smsMessage = new SmsMessage(phoneNumber, code);
smsMessage.Properties.Add("code", code);
smsMessage.Properties.Add("TemplateCode", templateCode);
await SmsSender.SendAsync(smsMessage);
}
return(RedirectToPage("VerifyCode", new
{
provider = Input.SelectedProvider,
returnUrl = ReturnUrl,
returnUrlHash = ReturnUrlHash,
rememberMe = RememberMe
}));
}