public virtual async Task <Data> SeedAsync(
string name,
string code,
string displayName,
string description = "",
Guid?parentId = null,
Guid?tenantId = null,
CancellationToken cancellationToken = default)
{
using (CurrentTenant.Change(tenantId))
{
var data = await DataRepository.FindByNameAsync(name, cancellationToken : cancellationToken);
if (data == null)
{
data = new Data(
GuidGenerator.Create(),
name,
code,
displayName,
description,
parentId,
tenantId);
data = await DataRepository.InsertAsync(data);
}
return(data);
}
}
public async Task <WalletAction> RechargeAsync(
Guid?tenantId,
Guid userId,
Guid rechargeProductId,
int productQuantity,
string orderId,
int creditAmount,
decimal paidAmount,
string title,
string description
)
{
using (CurrentTenant.Change(tenantId))
{
var coinPurchased = new WalletAction(GuidGenerator.Create(), tenantId, userId, rechargeProductId, productQuantity, orderId, creditAmount, paidAmount);
await _repository.InsertAsync(coinPurchased);
// 修改销售数量
var product = await _productRepository.GetAsync(rechargeProductId);
product.SetSoldQuantity(product.SoldQuantity + productQuantity);
// 钱包
var wallet = await _walletRepository.GetByUserIdAsync(userId);
wallet.IncBalance(creditAmount);
// 写日志
var log = new WalletLog(GuidGenerator.Create(), tenantId, userId, "Recharge", false, creditAmount, wallet.Balance, title, description);
await _walletLogRepository.InsertAsync(log);
return(coinPurchased);
}
}
public override Task <PermissionValueProviderGrantInfo> CheckAsync(string name, string providerName, string providerKey)
{
using (CurrentTenant.Change(null))
{
return(base.CheckAsync(name, providerName, providerKey));
}
}
public async Task <List <UserGroup> > GetGroupUsersAsync(Guid?tenantId, long groupId, string filter = "", string sorting = "UserId", int skipCount = 1, int maxResultCount = 10)
{
using (CurrentTenant.Change(tenantId))
{
return(await UserChatGroupRepository.GetGroupUsersAsync(groupId, filter, sorting, skipCount, maxResultCount));
}
}
protected virtual async Task TriggerHandlerAsync(IEventHandlerFactory asyncHandlerFactory, Type eventType,
object eventData, List <Exception> exceptions, InboxConfig inboxConfig = null)
{
using (var eventHandlerWrapper = asyncHandlerFactory.GetHandler())
{
try
{
var handlerType = eventHandlerWrapper.EventHandler.GetType();
if (inboxConfig?.HandlerSelector != null &&
!inboxConfig.HandlerSelector(handlerType))
{
return;
}
using (CurrentTenant.Change(GetEventDataTenantId(eventData)))
{
await EventHandlerInvoker.InvokeAsync(eventHandlerWrapper.EventHandler, eventData, eventType);
}
}
catch (TargetInvocationException ex)
{
exceptions.Add(ex.InnerException);
}
catch (Exception ex)
{
exceptions.Add(ex);
}
}
}
public async Task SetMemberMenusAsync_Test()
{
var adminMenu = await MenuRepository.FindByNameAsync("admin");
var saasMenu = await MenuRepository.FindByNameAsync("saas");
await MenuManager.SetUserMenusAsync(PlatformTestsConsts.User1Id, new Guid[] { adminMenu.Id });
await MenuManager.SetUserMenusAsync(PlatformTestsConsts.User2Id, new Guid[] { adminMenu.Id, saasMenu.Id });
(await Repository.UserHasInMenuAsync(PlatformTestsConsts.User1Id, "admin")).ShouldBeTrue();
(await Repository.UserHasInMenuAsync(PlatformTestsConsts.User2Id, "admin")).ShouldBeTrue();
(await Repository.UserHasInMenuAsync(PlatformTestsConsts.User2Id, "saas")).ShouldBeTrue();
using (CurrentTenant.Change(PlatformTestsConsts.TenantId))
{
// 在租户范围不能查询到宿主数据
(await Repository.UserHasInMenuAsync(PlatformTestsConsts.User1Id, "admin")).ShouldBeFalse();
(await Repository.UserHasInMenuAsync(PlatformTestsConsts.User2Id, "saas")).ShouldBeFalse();
var tenantSaasMenu = await MenuRepository.FindByNameAsync("saas");
await MenuManager.SetUserMenusAsync(PlatformTestsConsts.User2Id, new Guid[] { tenantSaasMenu.Id });
(await Repository.UserHasInMenuAsync(PlatformTestsConsts.User2Id, "admin")).ShouldBeFalse();
(await Repository.UserHasInMenuAsync(PlatformTestsConsts.User2Id, "saas")).ShouldBeTrue();
}
// 在租户范围内处理了菜单数据不应该影响到宿主
(await Repository.UserHasInMenuAsync(PlatformTestsConsts.User2Id, "admin")).ShouldBeTrue();
}
public async Task InsertNotificationAsync(NotificationInfo notification)
{
using (var unitOfWork = _unitOfWorkManager.Begin())
{
using (CurrentTenant.Change(notification.TenantId))
{
var notifyId = SnowflakeIdGenerator.Create();
// 保存主键，防止前端js long类型溢出
notification.Data["id"] = notifyId.ToString();
var notify = new Notification(notifyId, notification.Name,
notification.Data.GetType().AssemblyQualifiedName,
JsonSerializer.Serialize(notification.Data), notification.NotificationSeverity)
{
CreationTime = Clock.Now,
Type = notification.NotificationType,
ExpirationTime = Clock.Now.AddDays(60)
};
notify.SetTenantId(notification.TenantId);
await NotificationRepository.InsertAsync(notify);
notification.Id = notify.NotificationId;
await unitOfWork.SaveChangesAsync();
}
}
}
protected virtual async Task <TenantCacheItem> GetCacheItemAsync(Guid?id, string name)
{
var cacheKey = CalculateCacheKey(id, name);
var cacheItem = await Cache.GetAsync(cacheKey, considerUow : true);
if (cacheItem != null)
{
return(cacheItem);
}
if (id.HasValue)
{
using (CurrentTenant.Change(null)) //TODO: No need this if we can implement to define host side (or tenant-independent) entities!
{
var tenant = await TenantRepository.FindAsync(id.Value);
return(await SetCacheAsync(cacheKey, tenant));
}
}
if (!name.IsNullOrWhiteSpace())
{
using (CurrentTenant.Change(null)) //TODO: No need this if we can implement to define host side (or tenant-independent) entities!
{
var tenant = await TenantRepository.FindByNameAsync(name);
return(await SetCacheAsync(cacheKey, tenant));
}
}
throw new AbpException("Both id and name can't be invalid.");
}
public virtual async Task BindAsync(LoginInput input)
{
await CheckBindPolicyAsync();
var loginResult = await GetLoginResultAsync(input);
using var tenantChange = CurrentTenant.Change(loginResult.MiniProgram.TenantId);
await _identityOptions.SetAsync();
if (await _identityUserManager.FindByLoginAsync(loginResult.LoginProvider, loginResult.ProviderKey) != null)
{
throw new WechatAccountHasBeenBoundException();
}
var identityUser = await _identityUserManager.GetByIdAsync(CurrentUser.GetId());
(await _identityUserManager.AddLoginAsync(identityUser,
new UserLoginInfo(loginResult.LoginProvider, loginResult.ProviderKey,
WeChatManagementCommonConsts.WeChatUserLoginInfoDisplayName))).CheckErrors();
await UpdateMiniProgramUserAsync(identityUser, loginResult.MiniProgram, loginResult.UnionId,
loginResult.Code2SessionResponse.OpenId, loginResult.Code2SessionResponse.SessionKey);
await UpdateUserInfoAsync(identityUser, input.UserInfo);
}
protected virtual async Task <IdentityUser> FindUserAsync(string uniqueUserNameOrEmailAddress)
{
IdentityUser user = null;
using (CurrentTenant.Change(null))
{
user = await UserManager.FindByNameAsync(LoginInput.UserNameOrEmailAddress) ??
await UserManager.FindByEmailAsync(LoginInput.UserNameOrEmailAddress);
if (user != null)
{
return(user);
}
}
foreach (var tenant in await _tenantRepository.GetListAsync())
{
using (CurrentTenant.Change(tenant.Id))
{
user = await UserManager.FindByNameAsync(LoginInput.UserNameOrEmailAddress) ??
await UserManager.FindByEmailAsync(LoginInput.UserNameOrEmailAddress);
if (user != null)
{
return(user);
}
}
}
return(null);
}
public async Task <ArticleSale> GetAsync(Guid id, Guid?tenantId, bool includeDetails = true)
{
using (CurrentTenant.Change(tenantId))
{
return(await _repository.GetAsync(id, includeDetails));
}
}
public async Task HandleEventAsync(EntityDeletedEto <TenantEto> eventData)
{
using var unitOfWork = UnitOfWorkManager.Begin();
// 订阅租户删除事件,删除管理员角色所有权限
// TODO: 租户貌似不存在了,删除应该会失败
// 有缓存存在的话,可以获取到租户连接字符串
using (CurrentTenant.Change(eventData.Entity.Id))
{
// var grantPermissions = await PermissionGrantRepository.GetListAsync("R", "admin");
// EfCore MySql 批量删除还是一条一条的语句?
// PermissionGrantRepository.GetDbSet().RemoveRange(grantPermissions);
var dbContext = await PermissionGrantRepository.GetDbContextAsync();
var permissionEntityType = dbContext.Model.FindEntityType(typeof(PermissionGrant));
var permissionTableName = permissionEntityType.GetTableName();
var batchRmovePermissionSql = string.Empty;
if (dbContext.Database.IsMySql())
{
batchRmovePermissionSql = BuildMySqlBatchDeleteScript(permissionTableName, eventData.Entity.Id);
}
else
{
batchRmovePermissionSql = BuildSqlServerBatchDeleteScript(permissionTableName, eventData.Entity.Id);
}
await dbContext.Database.ExecuteSqlRawAsync(batchRmovePermissionSql);
await unitOfWork.SaveChangesAsync();
}
}
public virtual async Task <LoginOutput> LoginAsync(LoginInput input)
{
var loginResult = await GetLoginResultAsync(input);
using var tenantChange = CurrentTenant.Change(loginResult.MiniProgram.TenantId);
await _identityOptions.SetAsync();
using (var uow = UnitOfWorkManager.Begin(new AbpUnitOfWorkOptions(true), true))
{
var identityUser =
await _identityUserManager.FindByLoginAsync(loginResult.LoginProvider, loginResult.ProviderKey) ??
await _miniProgramLoginNewUserCreator.CreateAsync(input.UserInfo, loginResult.LoginProvider,
loginResult.ProviderKey);
await UpdateMiniProgramUserAsync(identityUser, loginResult.MiniProgram, loginResult.UnionId,
loginResult.Code2SessionResponse.OpenId, loginResult.Code2SessionResponse.SessionKey);
await UpdateUserInfoAsync(identityUser, input.UserInfo);
await uow.CompleteAsync();
}
return(new LoginOutput
{
TenantId = loginResult.MiniProgram.TenantId,
RawData = (await RequestIds4LoginAsync(input.AppId, loginResult.UnionId,
loginResult.Code2SessionResponse.OpenId))?.Raw
});
}
public virtual async Task SeedAsync(DataSeedContext context)
{
using (CurrentTenant.Change(context.TenantId))
{
var data = await SeedDefaultDataDictionaryAsync(context.TenantId);
// 预置
var layout = await SeedDefaultLayoutAsync(data);
// 首页
await SeedHomeMenuAsync(layout, data);
// 管理菜单预置菜单数据
await SeedAdminMenuAsync(layout, data);
// saas菜单数据
await SeedSaasMenuAsync(layout, data);
// 身份资源菜单数据
await SeedIdentityServerMenuAsync(layout, data);
// 审计日志菜单数据
await SeedAuditingMenuAsync(layout, data);
// 布局容器预置菜单数据
await SeedContainerMenuAsync(layout, data);
// 网关管理菜单数据
await SeedApiGatewayMenuAsync(layout, data);
// Oss对象管理菜单数据
await SeedOssManagementMenuAsync(layout, data);
}
}
public async Task <int> GetGroupUsersCountAsync(Guid?tenantId, long groupId, string filter = "")
{
using (CurrentTenant.Change(tenantId))
{
return(await UserChatGroupRepository.GetGroupUsersCountAsync(groupId, filter));
}
}
public async Task <WalletAction> GetAsync(Guid id, Guid?tenantId)
{
using (CurrentTenant.Change(tenantId))
{
return(await _repository.GetAsync(id));
}
}
protected override Task RevokeAsync(string name, string providerKey)
{
using (CurrentTenant.Change(null))
{
return(base.RevokeAsync(name, providerKey));
}
}
public virtual async Task UnbindAsync(LoginInput input)
{
await CheckUnbindPolicyAsync();
var loginResult = await GetLoginResultAsync(input);
using var tenantChange = CurrentTenant.Change(loginResult.MiniProgram.TenantId);
await _identityOptions.SetAsync();
if (await _identityUserManager.FindByLoginAsync(loginResult.LoginProvider, loginResult.ProviderKey) == null)
{
throw new WechatAccountHasNotBeenBoundException();
}
var identityUser = await _identityUserManager.GetByIdAsync(CurrentUser.GetId());
(await _identityUserManager.RemoveLoginAsync(identityUser, loginResult.LoginProvider, loginResult.ProviderKey)).CheckErrors();
await RemoveMiniProgramUserAsync(identityUser, loginResult.MiniProgram);
if (!await _miniProgramUserRepository.AnyAsync(x => x.UserId == identityUser.Id))
{
await RemoveUserInfoAsync(identityUser);
}
}
public override Task SetAsync(string name, string providerKey, bool isGranted)
{
using (CurrentTenant.Change(null))
{
return(base.SetAsync(name, providerKey, isGranted));
}
}
public virtual async Task <TenantDto> CreateAsync(TenantCreateDto input)
{
var tenant = await TenantManager.CreateAsync(input.Name);
input.MapExtraPropertiesTo(tenant);
await TenantRepository.InsertAsync(tenant);
await CurrentUnitOfWork.SaveChangesAsync();
await DistributedEventBus.PublishAsync(
new TenantCreatedEto
{
Id = tenant.Id,
Name = tenant.Name,
Properties =
{
{ "AdminEmail", input.AdminEmailAddress },
{ "AdminPassword", input.AdminPassword }
}
});
using (CurrentTenant.Change(tenant.Id, tenant.Name))
{
//TODO: Handle database creation?
// TODO: Seeder might be triggered via event handler.
await DataSeeder.SeedAsync(
new DataSeedContext(tenant.Id)
.WithProperty("AdminEmail", input.AdminEmailAddress)
.WithProperty("AdminPassword", input.AdminPassword)
);
}
return(ObjectMapper.Map <Tenant, TenantDto>(tenant));
}
/// <summary>
/// 获取当前租户产品总数
/// </summary>
/// <param name="tenantId">指定租户</param>
/// <returns></returns>
public async Task <long> GetProductCountAsync(Guid?tenantId)
{
// 使用using 可以在代码块结束后恢复原本租户值
using (CurrentTenant.Change(tenantId))
{
return(await ProductRepository.GetCountAsync());
}
}
public async override Task <IActionResult> OnGetAsync()
{
LoginInput = new LoginInputModel();
var context = await Interaction.GetAuthorizationContextAsync(ReturnUrl);
if (context != null)
{
ShowCancelButton = true;
LoginInput.UserNameOrEmailAddress = context.LoginHint;
//TODO: Reference AspNetCore MultiTenancy module and use options to get the tenant key!
var tenant = context.Parameters[TenantResolverConsts.DefaultTenantKey];
if (!string.IsNullOrEmpty(tenant))
{
CurrentTenant.Change(Guid.Parse(tenant));
Response.Cookies.Append(TenantResolverConsts.DefaultTenantKey, tenant);
}
}
if (context?.IdP != null)
{
LoginInput.UserNameOrEmailAddress = context.LoginHint;
ExternalProviders = new[] { new ExternalProviderModel {
AuthenticationScheme = context.IdP
} };
return(Page());
}
var providers = await GetExternalProviders();
ExternalProviders = providers.ToList();
EnableLocalLogin = await SettingProvider.IsTrueAsync(AccountSettingNames.EnableLocalLogin);
if (context?.Client?.ClientId != null)
{
var client = await ClientStore.FindEnabledClientByIdAsync(context?.Client?.ClientId);
if (client != null)
{
EnableLocalLogin = client.EnableLocalLogin;
if (client.IdentityProviderRestrictions != null && client.IdentityProviderRestrictions.Any())
{
providers = providers.Where(provider => client.IdentityProviderRestrictions.Contains(provider.AuthenticationScheme)).ToList();
}
}
}
if (IsExternalLoginOnly)
{
return(await base.OnPostExternalLogin(providers.First().AuthenticationScheme));
}
return(Page());
}
public async Task <GroupUserCard> GetUserGroupCardAsync(Guid?tenantId, long groupId, Guid userId)
{
using (CurrentTenant.Change(tenantId))
{
var groupUserCard = await UserChatGroupRepository.GetGroupUserCardAsync(groupId, userId);
return(groupUserCard);
}
}
public async Task <IEnumerable <Group> > GetUserGroupsAsync(Guid?tenantId, Guid userId)
{
using (CurrentTenant.Change(tenantId))
{
var groups = await UserChatGroupRepository.GetUserGroupsAsync(userId);
return(groups);
}
}
public override async Task <IActionResult> OnPostAsync(string action)
{
var user = await FindUserAsync(LoginInput.UserNameOrEmailAddress);
using (CurrentTenant.Change(user?.TenantId))
{
return(await base.OnPostAsync(action));
}
}
public override async Task <IActionResult> OnGetExternalLoginCallbackAsync(string returnUrl = "", string returnUrlHash = "", string remoteError = null)
{
var user = await FindUserAsync(LoginInput.UserNameOrEmailAddress);
using (CurrentTenant.Change(user?.TenantId))
{
return(await base.OnGetExternalLoginCallbackAsync(returnUrl, returnUrlHash, remoteError));
}
}
public async Task <NotificationInfo> GetNotificationOrNullAsync(Guid?tenantId, long notificationId)
{
using (CurrentTenant.Change(tenantId))
{
var notification = await NotificationRepository.GetByIdAsync(notificationId);
return(_objectMapper.Map <Notification, NotificationInfo>(notification));
}
}
public async Task <List <NotificationSubscriptionInfo> > GetSubscriptionsAsync(Guid?tenantId, string notificationName)
{
using (CurrentTenant.Change(tenantId))
{
var userSubscriptions = await UserSubscribeRepository.GetSubscribesAsync(notificationName);
return(_objectMapper.Map <List <UserSubscribe>, List <NotificationSubscriptionInfo> >(userSubscriptions));
}
}
public async Task <List <NotificationInfo> > GetUserNotificationsAsync(Guid?tenantId, Guid userId, NotificationReadState readState = NotificationReadState.UnRead, int maxResultCount = 10)
{
using (CurrentTenant.Change(tenantId))
{
var notifications = await UserNotificationRepository.GetNotificationsAsync(userId, readState, maxResultCount);
return(_objectMapper.Map <List <Notification>, List <NotificationInfo> >(notifications));
}
}
public async Task <IEnumerable <UserGroup> > GetGroupUsersAsync(Guid?tenantId, long groupId)
{
using (CurrentTenant.Change(tenantId))
{
var userGroups = await UserChatGroupRepository.GetGroupUsersAsync(groupId);
return(userGroups);
}
}
