public async Task <IActionResult> SignonHubbub([FromBody] BasicRegistModel model)
        {
            if (ModelState.IsValid)
            {
                try

                {
                    var user   = CreateBasicAccount(model, RegisterType.Hubbub);
                    var result = await _userManager.CreateAsync(user, model.Password);

                    //result.Errors
                    if (result.Succeeded)
                    {
                        var role_add_result = await _userManager.AddToRoleAsync(user, UserRoleTypes.HubbubUser);

                        return(Ok(new { Result = role_add_result }));
                    }
                    else
                    {
                        return(BadRequest(new { Result = result }));
                    }
                }
                catch (Exception ex)
                {
                    logger.LogError(ex, ex.Message);
                    return(BadRequest(ex.Message));
                }
            }
            return(BadRequest());
        }
        //[ValidateAntiForgeryToken]
        public async Task <IActionResult> SignonAccountManager([FromBody] BasicRegistModel model)
        {
            if (ModelState.IsValid)
            {
                try

                {
                    var user   = CreateBasicAccount(model, RegisterType.AccountManager);
                    var result = await _userManager.CreateAsync(user, model.Password);

                    //result.Errors
                    if (result.Succeeded)
                    {
                        var role_add_result = await _userManager.AddToRoleAsync(user, UserRoleTypes.AccountManager);

                        ////_userManager.AddClaimAsync(user, new Claim())
                        //SupervisorUserEF aggregatorUser = new SupervisorUserEF();
                        //aggregatorUser.UserId = user.Id;
                        //await _accountContext.SupervisorUsers.AddAsync(aggregatorUser);
                        //await _accountContext.SaveChangesAsync();
                        return(Ok(new { Result = role_add_result }));
                    }
                    else
                    {
                        return(BadRequest(new { Result = result }));
                    }
                }
                catch (Exception ex)
                {
                    logger.LogError(ex, ex.Message);
                    return(BadRequest(ex.Message));
                }
            }
            return(BadRequest());
        }
        //[ValidateAntiForgeryToken]
        public async Task <IActionResult> SignonSupervisor([FromBody] BasicRegistModel model)
        {
            if (ModelState.IsValid)
            {
                var trans = await _accountContext.Database.BeginTransactionAsync();

                try

                {
                    var user   = CreateSupervisorAccount(model);
                    var result = await _userManager.CreateAsync(user, model.Password);

                    //result.Errors
                    if (result.Succeeded)
                    {
                        var role_add_result = await _userManager.AddToRoleAsync(user, UserRoleTypes.Supervisor);

                        //_userManager.AddClaimAsync(user, new Claim())
                        SupervisorUserEF aggregatorUser = new SupervisorUserEF();
                        aggregatorUser.UserId = user.Id;
                        await _accountContext.SupervisorUsers.AddAsync(aggregatorUser);

                        await _accountContext.SaveChangesAsync();

                        trans.Commit();
                        return(Ok(new { Result = result }));
                    }
                    else
                    {
                        trans.Rollback();
                        return(BadRequest(new { Result = result }));
                    }
                }
                catch (Exception ex)
                {
                    trans.Dispose();
                    logger.LogError(ex, ex.Message);
                    return(BadRequest(ex.Message));
                }
            }
            return(BadRequest());
        }
        private UserAccountEF CreateBasicAccount(BasicRegistModel model, RegisterType userType)
        {
            var user = new UserAccountEF
            {
                FirstName          = model.FirstName,
                LastName           = model.LastName,
                Email              = model.Email,
                UserName           = model.Email,
                CompanyName        = "파워이십일",
                NormalizedUserName = model.Email.ToUpper(),
                PhoneNumber        = model.PhoneNumber,
                Address            = "파워이십일",
                RegistDate         = DateTime.Now,
                Expire             = new DateTime(2100, 12, 31),
                UserType           = userType,
                RegistrationNumber = ""
            };

            return(user);
        }
        private UserAccountEF CreateSupervisorAccount(BasicRegistModel model)
        {
            var user = new UserAccountEF
            {
                FirstName          = model.FirstName,
                LastName           = model.LastName,
                Email              = model.Email,
                UserName           = model.Email,
                CompanyName        = "파워이십일",
                NormalizedUserName = model.Email.ToUpper(),
                PhoneNumber        = model.PhoneNumber,
                Address            = "대전광역시 유성과 관평동 1359번지 한신에스메카 609호",
                RegistDate         = DateTime.Now,
                Expire             = DateTime.Now.AddMonths(1),
                UserType           = RegisterType.Supervisor,
                RegistrationNumber = "",
                SignInConfirm      = true
            };

            return(user);
        }