Example #1
0
        public async Task <IActionResult> Add([FromBody] CreateSupplierCommand createSupplierCommand)
        {
            ResultWrapper <RegisterOutput> result = new ResultWrapper <RegisterOutput>();

            createSupplierCommand.Role = AppEnums.RoleEnum.Supplier;
            RegisterCommand registerCommand = new RegisterCommand()
            {
                Gender   = createSupplierCommand.Gender,
                Username = createSupplierCommand.Email,
                Password = createSupplierCommand.Password,
                Role     = createSupplierCommand.Role
            };

            result = await _mediator.Send(registerCommand);

            if (!result.Status)
            {
                return(Ok(result));
            }
            AdminRegisterEvent opEvent = new AdminRegisterEvent()
            {
                Request  = registerCommand,
                Response = result.Result
            };
            await _mediator.Publish(opEvent);

            createSupplierCommand.FireBaseId = result.Result.LocalId;
            ResultWrapper <CreateSupplierOutput> createSupplierResult = await _mediator.Send(createSupplierCommand);

            return(Ok(createSupplierResult));
        }
Example #2
0
        public async Task <IActionResult> Register([FromBody] RegisterCommand model)
        {
            ResultWrapper <RegisterOutput> result = new ResultWrapper <RegisterOutput>();

            model.Role = AppEnums.RoleEnum.Admin;
            result     = await _mediator.Send(model);

            if (result.Status)
            {
                AdminRegisterEvent opEvent = new AdminRegisterEvent()
                {
                    Request  = model,
                    Response = result.Result
                };
                await _mediator.Publish(opEvent);

                CreateUserCommand createUserCommand = new CreateUserCommand()
                {
                    Email      = model.Username,
                    FireBaseId = result.Result.LocalId,
                    Gender     = model.Gender,
                    Role       = AppEnums.RoleEnum.Admin
                };
                ResultWrapper <CreateUserOutput> createUserResult = await _mediator.Send(createUserCommand);
            }
            return(Ok(result));
        }
        public static async Task InitializeAsync(UserManager <User> userManager, RoleManager <IdentityRole> roleManager, IEventBus eventBus)
        {
            if (await roleManager.FindByNameAsync(Roles.LecturerRole) == null)
            {
                await roleManager.CreateAsync(Roles.Lecturer);
            }

            if (await roleManager.FindByNameAsync(Roles.StudentRole) == null)
            {
                await roleManager.CreateAsync(Roles.Student);
            }

            const string email    = "*****@*****.**";
            const string password = "******";

            if (await userManager.FindByEmailAsync(email) == null)
            {
                var admin = new User {
                    Email    = email,
                    Name     = "Admin",
                    UserName = "******"
                };

                var result = await userManager.CreateAsync(admin, password);

                if (result.Succeeded)
                {
                    await userManager.AddToRoleAsync(admin, Roles.LecturerRole); //TODO: dangerous

                    admin.EmailConfirmed = true;
                    await userManager.UpdateAsync(admin);

                    var @event = new AdminRegisterEvent(admin.Id, admin.Email, admin.Name);
                    eventBus.Publish(@event);
                }
            }
        }