public async Task CreateTenant(CreateTenantInput input)
        {
            //Create tenant
            var tenant = new Tenant(input.TenancyName, input.Name);
            var defaultEdition = await _editionManager.FindByNameAsync(EditionManager.DefaultEditionName);
            if (defaultEdition != null)
            {
                tenant.EditionId = defaultEdition.Id;
            }

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

            //We are working entities of new tenant, so changing tenant filter
            using (CurrentUnitOfWork.SetFilterParameter(AbpDataFilters.MayHaveTenant, AbpDataFilters.Parameters.TenantId, tenant.Id))
            {
                //Create static roles for new tenant
                CheckErrors(await _roleManager.CreateStaticRoles(tenant.Id));

                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, input.AdminEmailAddress, User.DefaultPassword);
                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();
            }
        }
 public async Task CreateTenant(CreateTenantInput input)
 {
     await TenantManager.CreateWithAdminUserAsync(input.TenancyName,
                                                  input.Name,
                                                  input.AdminPassword,
                                                  input.AdminEmailAddress,
                                                  input.ConnectionString,
                                                  input.IsActive,
                                                  input.EditionId,
                                                  input.ShouldChangePasswordOnNextLogin,
                                                  input.SendActivationEmail,
                                                  input.SubscriptionEndDateUtc?.ToUniversalTime(),
                                                  input.IsInTrialPeriod,
                                                  AppUrlService.CreateEmailActivationUrlFormat(input.TenancyName)
                                                  );
 }
        public async Task CreateAsync(CreateTenantInput input)
        {
            // Create tenant
            var tenant = ObjectMapper.Map <Tenant>(input);

            tenant.ConnectionString = input.ConnectionString.IsNullOrEmpty()
                ? null
                : SimpleStringCipher.Instance.Encrypt(input.ConnectionString);

            var defaultEdition = await _editionManager.FindByNameAsync(EditionManager.DefaultEditionName);

            if (defaultEdition != null)
            {
                tenant.EditionId = defaultEdition.Id;
            }

            await _tenantManager.CreateAsync(tenant);

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

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

            // We are working entities of new tenant, so changing tenant filter
            using (CurrentUnitOfWork.SetTenantId(tenant.Id))
            {
                // Create static roles for new tenant
                CheckErrors(await _roleManager.CreateStaticRoles(tenant.Id));

                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, input.AdminEmailAddress);
                await _userManager.InitializeOptionsAsync(tenant.Id);

                CheckErrors(await _userManager.CreateAsync(adminUser, User.DefaultPassword));
                await CurrentUnitOfWork.SaveChangesAsync(); // To get admin user's id

                // Assign admin user to role!
                CheckErrors(await _userManager.AddToRoleAsync(adminUser, adminRole.Name));
                await CurrentUnitOfWork.SaveChangesAsync();
            }
        }
Ejemplo n.º 4
0
 public async Task Create(CreateTenantInput input)
 {
     await TenantManager.CreateWithAdminUser(
         input.TenancyName,
         input.Name,
         input.AdminPassword,
         input.AdminEmailAddress,
         input.ConnectionString,
         input.IsActive,
         input.EditionId,
         input.ShouldChangePasswordOnNextLogin,
         input.SendActivationEmail,
         input.SubscriptionEndUtc,
         input.IsInTrialPeriod,
         null // TODO: 这里创建激活链接
         );
 }
Ejemplo n.º 5
0
        public async Task CreateTenantAsync(CreateTenantInput input)
        {
            var tenant = input.Tenant.MapTo <Tenant>();

            if (!tenant.EditionId.HasValue)
            {
                var defaultEdition = await _editionManager.FindByNameAsync(EditionManager.DefaultEditionName);

                if (defaultEdition != null)
                {
                    tenant.EditionId = defaultEdition.Id;
                }
            }

            //添加租户
            CheckErrors(await TenantManager.CreateAsync(tenant));
            CurrentUnitOfWork.SaveChanges();
            using (CurrentUnitOfWork.SetFilterParameter(AbpDataFilters.MayHaveTenant, AbpDataFilters.Parameters.TenantId, tenant.Id))
            {
                //添加租户静态角色(管理员角色 普通用户角色)
                CheckErrors(await _roleManager.CreateStaticRoles(tenant.Id));
                await CurrentUnitOfWork.SaveChangesAsync();

                //把租户的部分权限赋予  管理员角色
                var adminRole = _roleManager.Roles.Single(r => r.Name == StaticRoleNames.Tenants.Admin);
                await _roleManager.GrantAllAdminPermissionsAsync(adminRole);

                //把租户的部分权限赋予 普通用户角色
                var userRole = _roleManager.Roles.Single(r => r.Name == StaticRoleNames.Tenants.User);
                //设置新添加客户时默认添加的角色
                userRole.IsDefault = true;
                await _roleManager.GrantAllUserPermissionsAsync(userRole);

                //管理员账户
                var adminUser = User.CreateTenantAdminUser(tenant.Id, input.Tenant.TenancyName, input.Tenant.EmailAddress, SpartanConsts.DefaultPassword);
                CheckErrors(await UserManager.CreateAsync(adminUser));
                await CurrentUnitOfWork.SaveChangesAsync();

                //给管理员赋予管理员角色
                CheckErrors(await UserManager.AddToRoleAsync(adminUser.Id, adminRole.Name));
                await CurrentUnitOfWork.SaveChangesAsync();
            }
        }
Ejemplo n.º 6
0
        public async Task CreateTenant(CreateTenantInput input)
        {
            var tenant = new Tenant(input.Name, input.Host);
            //var defaultEdition = await _editionManager.FindByNameAsync(EditionManager.DefaultEditionName);
            //if (defaultEdition != null)
            //{
            //    tenant.EditionId = defaultEdition.Id;
            //}

            //Create tenant

            /*
             * CheckErrors(_tenantManager.Register(tenant));
             * await CurrentUnitOfWork.SaveChangesAsync(); //To get new tenant's id.
             *
             * //We are working entities of new tenant, so changing tenant filter
             * using (CurrentUnitOfWork.SetFilterParameter(AbpDataFilters.MayHaveTenant, AbpDataFilters.Parameters.TenantId, tenant.Id))
             * {
             *  //Create static roles for new tenant
             *  CheckErrors(await _roleManager.CreateStaticRoles(tenant.Id));
             *
             *  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, input.AdminEmailAddress, User.DefaultPassword);
             *  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();
             * }
             */
        }
Ejemplo n.º 7
0
        private async Task CreateAdminAndRole(long tenantId, CreateTenantInput input, DbConnection conn,
                                              DbTransaction trans)
        {
            var tenantConfig = _tenantConfigProvider.Get();

            if (tenantConfig == null || tenantConfig.SuperUserPassword.IsNullOrWhiteSpace() ||
                tenantConfig.SuperUserPassword.IsNullOrWhiteSpace())
            {
                throw new BusinessException("获取租户默认管理员账号和密码失败");
            }

            var permissions = await _permissionRepository.GetAllAsync();

            var createRole = new CreateRoleInput()
            {
                Identification     = input.Identification + "_admin",
                Name               = "管理员",
                PermissionIds      = permissions.Select(p => p.Id).ToArray(),
                DataPermissionType = DataPermissionType.AllOrg,
                IsAllOrg           = true,
                Memo               = "创建租户时,初始化的角色",
            };
            var roleId = await _roleDomainService.Create(createRole, conn, trans, tenantId);

            var createUser = new CreateUserInput()
            {
                OrgId       = null,
                UserName    = tenantConfig.SuperUserAccount,
                Password    = tenantConfig.SuperUserPassword,
                ChineseName = tenantConfig.ChineseName ?? "管理员",
                Memo        = "创建租户时,初始化的用户",
                RoleIds     = new[] { roleId },
                Status      = Common.Status.Valid
            };
            await _userDomainService.Create(createUser, conn, trans, tenantId);
        }
 public async Task CreateTenant(CreateTenantInput input)
 {
     await ApiClient.PostAsync(GetEndpoint(nameof(CreateTenant)), input);
 }
Ejemplo n.º 9
0
        public async Task <JsonResult> CreateTenant(CreateTenantInput input)
        {
            await _tenantAppService.CreateTenantAsync(input);

            return(Json(true, JsonRequestBehavior.AllowGet));
        }
Ejemplo n.º 10
0
 public async Task <string> Create(CreateTenantInput input)
 {
     input.CheckDataAnnotations().CheckValidResult();
     return(await _tenantDomainService.Create(input));
 }
Ejemplo n.º 11
0
        public async Task CreateTenant(CreateTenantInput input)
        {
            int  newTenantId;
            long newAdminId;

            using (var uow = UnitOfWorkManager.Begin())
            {
                //Create tenant
                var tenant = new Tenant(input.TenancyName, input.Name)
                {
                    IsActive = input.IsActive, EditionId = input.EditionId
                };
                CheckErrors(await TenantManager.CreateAsync(tenant));
                await CurrentUnitOfWork.SaveChangesAsync(); //To get new tenant's id.

                //We are working entities of new tenant, so changing tenant filter
                using (CurrentUnitOfWork.SetFilterParameter(AbpDataFilters.MayHaveTenant, AbpDataFilters.Parameters.TenantId, tenant.Id))
                {
                    //Create static roles for new tenant
                    CheckErrors(await _roleManager.CreateStaticRoles(tenant.Id));
                    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);

                    //User role should be default
                    var userRole = _roleManager.Roles.Single(r => r.Name == StaticRoleNames.Tenants.User);
                    userRole.IsDefault = true;
                    CheckErrors(await _roleManager.UpdateAsync(userRole));

                    //Create admin user for the tenant
                    if (input.AdminPassword.IsNullOrEmpty())
                    {
                        input.AdminPassword = User.CreateRandomPassword();
                    }

                    var adminUser = User.CreateTenantAdminUser(tenant.Id, input.AdminEmailAddress, input.AdminPassword);
                    adminUser.ShouldChangePasswordOnNextLogin = input.ShouldChangePasswordOnNextLogin;
                    adminUser.IsActive = input.IsActive;

                    CheckErrors(await UserManager.CreateAsync(adminUser));
                    await CurrentUnitOfWork.SaveChangesAsync(); //To get admin user's id

                    //Assign admin user to admin role!
                    CheckErrors(await UserManager.AddToRoleAsync(adminUser.Id, adminRole.Name));

                    //Notifications
                    await _appNotifier.WelcomeToTheApplicationAsync(adminUser);

                    //Send activation email
                    if (input.SendActivationEmail)
                    {
                        adminUser.SetNewEmailConfirmationCode();
                        await _userEmailer.SendEmailActivationLinkAsync(adminUser, input.AdminPassword);
                    }

                    await CurrentUnitOfWork.SaveChangesAsync();

                    await _demoDataBuilder.BuildForAsync(tenant);

                    newTenantId = tenant.Id;
                    newAdminId  = adminUser.Id;
                }

                await uow.CompleteAsync();
            }

            //Used a second UOW since UOW above sets some permissions and _notificationSubscriptionManager.SubscribeToAllAvailableNotificationsAsync needs these permissions to be saved.
            using (var uow = UnitOfWorkManager.Begin())
            {
                using (CurrentUnitOfWork.SetFilterParameter(AbpDataFilters.MayHaveTenant, AbpDataFilters.Parameters.TenantId, newTenantId))
                {
                    await _notificationSubscriptionManager.SubscribeToAllAvailableNotificationsAsync(newTenantId, newAdminId);

                    await CurrentUnitOfWork.SaveChangesAsync();
                }

                await uow.CompleteAsync();
            }
        }
Ejemplo n.º 12
0
 public CreateTenantViewModel()
 {
     Tenant = new CreateTenantInput();
 }