protected async Task <ActionResult> RegistrarUsuario(InfoUserViewModel infoUser)
{
var user = new IdentityUser
{
UserName = infoUser.Email,
Email = infoUser.Email,
EmailConfirmed = true
};
var result = await _userManager.CreateAsync(user, infoUser.Senha);
if (!result.Succeeded)
{
return(BadRequest(new { result.Errors }));
}
if (infoUser.Role == RoleType.ADMINISTRADOR)
{
await _userManager.AddToRoleAsync(user, "Administrador");
}
else
{
await _userManager.AddToRoleAsync(user, "Usuario");
}
await _signInManager.SignInAsync(user, false);
return(Ok());
}
public async Task <JObject> Details(string viewType, string id = null)
{
switch (viewType)
{
case "be":
if (!string.IsNullOrEmpty(id))
{
var beResult = await BEUserViewModel.Repository.GetSingleModelAsync(
model => model.Id == id).ConfigureAwait(false);
beResult.Data.Specificulture = _lang;
return(JObject.FromObject(beResult));
}
else
{
var model = new SiocCmsUser()
{
Status = (int)SWStatus.Preview
};
RepositoryResponse <BEUserViewModel> result = new RepositoryResponse <BEUserViewModel>()
{
IsSucceed = true,
Data = await BEUserViewModel.InitViewAsync(model)
};
result.Data.Specificulture = _lang;
return(JObject.FromObject(result));
}
default:
if (!string.IsNullOrEmpty(id))
{
var beResult = await InfoUserViewModel.Repository.GetSingleModelAsync(
model => model.Id == id).ConfigureAwait(false);
beResult.Data.Specificulture = _lang;
return(JObject.FromObject(beResult));
}
else
{
var model = new SiocCmsUser()
{
Status = (int)SWStatus.Preview
};
RepositoryResponse <InfoUserViewModel> result = new RepositoryResponse <InfoUserViewModel>()
{
IsSucceed = true,
Data = await InfoUserViewModel.InitViewAsync(model)
};
result.Data.Specificulture = _lang;
return(JObject.FromObject(result));
}
}
}
public async Task <RepositoryResponse <InfoUserViewModel> > Save(
[FromBody] InfoUserViewModel model)
{
if (model != null)
{
var result = await model.SaveModelAsync(true).ConfigureAwait(false);
return(result);
}
return(new RepositoryResponse <InfoUserViewModel>());
}
public async Task <IActionResult> RegisterSuperAdmin(RegisterViewModel model, string returnUrl = null)
{
var superAdmin = await _userManager.GetUsersInRoleAsync("SuperAdmin");
if (superAdmin.Count > 0)
{
return(RedirectToAction("Register"));
}
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = model.UserName,
Email = model.Email,
NickName = model.Email,
FirstName = model.Email,
LastName = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password).ConfigureAwait(false);
await _userManager.AddToRoleAsync(user, "SuperAdmin");
if (result.Succeeded)
{
// Save to cms db context
InfoUserViewModel cmsUser = new InfoUserViewModel()
{
Id = user.Id,
Username = model.UserName,
FirstName = model.FirstName,
LastName = model.LastName,
CreatedDateTime = DateTime.UtcNow
};
await cmsUser.SaveModelAsync().ConfigureAwait(false);
await _signInManager.SignInAsync(user, isPersistent : false).ConfigureAwait(false);
_logger.LogInformation(3, "User created a new account with password.");
return(RedirectToLocal(returnUrl));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public virtual async Task <ActionResult> Desativar(InfoUserViewModel infoUser)
{
var user = await _userManager.FindByEmailAsync(infoUser.Email);
if (!user.LockoutEnabled)
{
var result = await _userManager.SetLockoutEnabledAsync(user, true);
if (!result.Succeeded)
{
return(BadRequest(new { Errors = result.Errors }));
}
}
return(Ok());
}
public async Task <ActionResult> Logar(InfoUserViewModel loginUser)
{
var result = await _signInManager.PasswordSignInAsync(loginUser.Email, loginUser.Senha, false, true);
if (result.Succeeded)
{
return(Ok(await GerarJwt(loginUser.Email)));
}
if (result.IsLockedOut)
{
return(BadRequest(new { Errors = new[] { "LockedOut" } }));
}
return(Ok(loginUser));
}
public async Task <RepositoryResponse <AccessTokenViewModel> > Register(RegisterViewModel model)
{
RepositoryResponse <AccessTokenViewModel> result = new RepositoryResponse <AccessTokenViewModel>();
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = model.UserName,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
JoinDate = DateTime.UtcNow
};
var createResult = await _userManager.CreateAsync(user, password : model.Password).ConfigureAwait(false);
if (createResult.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
user = await _userManager.FindByEmailAsync(model.Email).ConfigureAwait(false);
// Save to cms db context
InfoUserViewModel cmsUser = new InfoUserViewModel()
{
Id = user.Id,
Username = model.UserName,
FirstName = model.FirstName,
LastName = model.LastName,
CreatedDateTime = DateTime.UtcNow
};
await cmsUser.SaveModelAsync();
var token = await GenerateAccessTokenAsync(user);
if (token != null)
{
result.IsSucceed = true;
result.Data = token;
_logger.LogInformation("User logged in.");
return(result);
}
else
{
return(result);
}
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
//await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);
//await _signInManager.SignInAsync(user, isPersistent: false);
//_logger.LogInformation("User created a new account with password.");
}
else
{
foreach (var error in createResult.Errors)
{
result.Errors.Add(error.Description);
}
return(result);
}
}
return(result);
}
public Task <ActionResult> Registrar(InfoUserViewModel infoUser)
{
infoUser.Role = RoleType.USUARIO;
return(RegistrarUsuario(infoUser));
}
public Task <ActionResult> Registrar(InfoUserViewModel infoUser)
{
infoUser.Role = RoleType.ADMINISTRADOR;
return(RegistrarUsuario(infoUser));
}
