App_V2.3/SourceCode/WeApp.Application/BaseSystem/Tenants/TenantsAppService.cs

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Web.Mvc;
using System.Web.WebPages;
using Abp.Application.Services.Dto;
using Abp.Auditing;
using Abp.Authorization;
using Abp.Domain.Repositories;
using Abp.Runtime.Caching;
using Abp.Runtime.Security;
using WeApp.Authorization;
using WeApp.Authorization.Roles;
using WeApp.Authorization.Users;
using WeApp.BaseSystem.Tenants.Dto;
using WeApp.Configuration;
using WeApp.MultiTenancy;
using IwbZero.AppServiceBase;
using IwbZero.Authorization.Base.SystemInfo;

namespace WeApp.BaseSystem.Tenants
{
    [AbpAuthorize]
    public class TenantsAppService : IwbAsyncCrudAppService<Tenant, TenantDto, int, IwbPagedRequestDto, TenantCreateDto, TenantUpdateDto>
        , ITenantsAppService
    {
        public TenantsAppService(
            ICacheManager cacheManager,
            IRepository<Tenant, int> repository, TenantManager tenantManager, RoleManager roleManager, UserManager userManager, IRepository<SysSetting, long> settingRepository) : base(repository, "")
        {
            _tenantManager = tenantManager;
            _roleManager = roleManager;
            _userManager = userManager;
            _settingRepository = settingRepository;
            CacheManager = cacheManager;
        }
        private readonly TenantManager _tenantManager;
        private readonly IRepository<SysSetting, long> _settingRepository;
        // private readonly EditionManager _editionManager;
        private readonly RoleManager _roleManager;
        private readonly UserManager _userManager;
        //private readonly IIwbDbMigrator _iwbDbMigrator;Tenant
        protected override bool KeyIsAuto { get; set; } = false;

        #region GetSelect

        [DisableAuditing]
        public override async Task<List<SelectListItem>> GetSelectList()
        {
            var list = await Repository.GetAllListAsync();
            var sList = new List<SelectListItem> { new SelectListItem { Text = @"请选择...", Value = "", Selected = true } };
            foreach (var l in list)
            {
                sList.Add(new SelectListItem { Text = l.Name, Value = l.TenancyName });
            }
            return sList;
        }
        [DisableAuditing]
        public override async Task<string> GetSelectStr()
        {
            var list = await Repository.GetAllListAsync();
            string str = "<option value=\"\" selected>请选择...</option>";
            foreach (var l in list)
            {
                str += $"<option value=\"{l.TenancyName}\">{l.Name}</option>";
            }
            return str;
        }

        #endregion

        #region CURD

        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesSystemMgTenantMgQuery)]
        public override async Task<PagedResultDto<TenantDto>> GetAll(IwbPagedRequestDto input)
        {
            var query = CreateFilteredQuery(input);
            query = ApplyFilter(query, input);
            var totalCount = await AsyncQueryableExecuter.CountAsync(query);
            query = ApplySorting(query, input);
            query = ApplyPaging(query, input);
            var entities = await AsyncQueryableExecuter.ToListAsync(query);
            var dtos = new PagedResultDto<TenantDto>(
                totalCount,
                entities.Select(MapToEntityDto).ToList()
            );
            return dtos;
        }

        [AbpAuthorize(PermissionNames.PagesSystemMgTenantMgCreate)]
        public override async Task Create(TenantCreateDto input)
        {
            //Create tenant
            var tenant = ObjectMapper.Map<Tenant>(input);
            input.ConnectionString =
                System.Web.Configuration.WebConfigurationManager.ConnectionStrings[IwbConsts.ConnectionStringName].ToString();
            tenant.ConnectionString = input.ConnectionString.IsEmpty()
                ? null
                : SimpleStringCipher.Instance.Encrypt(input.ConnectionString);

            await _tenantManager.CreateAsync(tenant);
            await CurrentUnitOfWork.SaveChangesAsync(); //To get new tenant's id.

            //Create tenant database
            //_iwbDbMigrator.CreateOrMigrateForTenant(tenant);

            //We are working entities of new tenant, so changing tenant filter
            //var settings = await _settingRepository.GetAllListAsync(a => a.Type > 0);
            using (CurrentUnitOfWork.SetTenantId(tenant.Id))
            {
                //Create static roles for new tenant
                var role = Role.CreateStaticRoles(tenant.Id);
                CheckErrors(await _roleManager.CreateStaticRoles(tenant.Id, role));

                await CurrentUnitOfWork.SaveChangesAsync(); //To get static role ids

                //grant all permissions to admin role
                var adminRole = _roleManager.Roles.Single(r => r.Name == StaticRoleNames.Tenants.Admin);
                await _roleManager.GrantAllPermissionsAsync(adminRole);

                //Create admin user for the tenant
                var adminUser = User.CreateTenantAdminUser(tenant.Id);
                CheckErrors(await _userManager.CreateAsync(adminUser));
                await CurrentUnitOfWork.SaveChangesAsync(); //To get admin user's id

                //Assign admin user to role!
                CheckErrors(await _userManager.AddToRoleAsync(adminUser.Id, adminRole.Name));
                await CurrentUnitOfWork.SaveChangesAsync();
                await SettingManager.ChangeSettingForTenantAsync(tenant.Id, IwbSettingNames.AdminSystemName, tenant.Name);
                //foreach (var setting in settings)
                //{
                //    if (setting.Name == SettingNames.AdminSystemName)
                //    {
                //        setting.Value = tenant.Name;
                //    }
                //    
                //    if (await _settingRepository.GetAllListAsync(a => a.Name ==setting.Name)==null)
                //    {
                //        await _settingRepository.InsertAsync(setting);
                //    }
                //}
            }
        }

        [AbpAuthorize(PermissionNames.PagesSystemMgTenantMgUpdate)]
        public override async Task Update(TenantUpdateDto input)
        {
            await UpdateEntity(input);
        }
        [AbpAuthorize(PermissionNames.PagesSystemMgTenantMgDelete)]
        public override async Task Delete(EntityDto<int> input)
        {
            var tenant = await _tenantManager.GetByIdAsync(input.Id);
            await _tenantManager.DeleteAsync(tenant);
        }

        #endregion
    }
}