private async Task <IActionResult> ReturnToken(TodoUser user)
{
var userClaims = await _userMgr.GetClaimsAsync(user);
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Sub, user.UserName),
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Email, user.Email)
}.Union(userClaims);
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_config["Tokens:Key"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
issuer: _config["Tokens:Issuer"],
audience: _config["Tokens:Audience"],
claims: claims,
expires: DateTime.UtcNow.AddMinutes(15),
signingCredentials: creds
);
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(token),
expiration = token.ValidTo
}));
}
public async Task <IActionResult> Login([FromBody] LoginVM pLoginVm)
{
try
{
TodoUser objTdUser = await _userManager.FindByEmailAsync(pLoginVm.Email);
if (objTdUser == null)
{
throw new Exception("The Email doesn't regitered");
}
var pbjSignInResult = await _signInManager.PasswordSignInAsync(objTdUser.UserName, pLoginVm.Password, false, false);
if (pbjSignInResult.Succeeded)
{
UserVM objUserRet = new UserVM()
{
Id = objTdUser.Id,
Email = objTdUser.Email,
Name = objTdUser.Name
};
return(Ok(new { Data = objUserRet, Status = "Success" }));
}
else
{
_logger.LogTrace($"End ApiAuthController.Login");
return(BadRequest(new { Status = "Error", Error = "Username or password incorrect" }));
}
}
catch (Exception ex)
{
_logger.LogError($"Error ApiAuthController.Login --> {ex.Message}");
return(BadRequest(new { Status = "Error", Error = $"{ex.Message}" }));
}
}
public async Task <IActionResult> PutTodoUser(int id, TodoUser todoUser)
{
if (id != todoUser.Id)
{
return(BadRequest());
}
_context.Entry(todoUser).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TodoUserExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <TodoUser> > PostTodoUser(TodoUser todoUser)
{
_context.TodoUsers.Add(todoUser);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTodoUser", new { id = todoUser.Id }, todoUser));
}
private async Task <string> CreateTokenAsync(TodoUser user)
{
var secret = configuration["JWT:Secret"];
var secretBytes = Encoding.UTF8.GetBytes(secret);
var signingKey = new SymmetricSecurityKey(secretBytes);
var principal = await signInManager.CreateUserPrincipalAsync(user);
var identity = (ClaimsIdentity)principal.Identity;
identity.AddClaims(new[]
{
new Claim("UserId", user.Id),
new Claim("FullName", $"{user.FirstName} {user.LastName}"),
});
var token = new JwtSecurityToken(
expires: DateTime.UtcNow.AddMonths(4),
claims: identity.Claims,
signingCredentials: new SigningCredentials(signingKey, SecurityAlgorithms.HmacSha256)
);
var tokenString = new JwtSecurityTokenHandler().WriteToken(token);
return(tokenString);
}
public ActionResult Create(Todo todo)
{
if (!ModelState.IsValid)
{
return(View());
}
var todoCreated = new Todo();
todoCreated.Name = todo.Name;
todoCreated.Description = todo.Description;
todoCreated.DueDate = todo.DueDate;
todoCreated.CategoryId = todo.CategoryId;
_context.Todos.Add(todoCreated);
var currentUserId = User.Identity.GetUserId();
var todoUser = new TodoUser()
{
TodoId = todoCreated.Id,
UserId = currentUserId
};
_context.TodoUsers.Add(todoUser);
_context.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Register(RegisterData register)
{
var user = new TodoUser
{
Email = register.Email,
UserName = register.Email,
FirstName = register.FirstName,
LastName = register.LastName,
};
var result = await userManager.CreateAsync(user, register.Password);
if (!result.Succeeded)
{
return(BadRequest(new
{
message = "Registration did not succeed",
errors = result.Errors,
}));
}
//if (User.IsInRole("Administrator") || !await userManager.Users.AnyAsync())
//{
// await userManager.AddToRolesAsync(user, register.Roles);
//}
return(Ok(new
{
UserId = user.Id,
Token = await CreateTokenAsync(user)
}));
}
public async Task DeleteUser(TodoUser todoUser)
{
var todoUserSet = _dbcontext.Set <TodoUser>();
todoUserSet.Remove(todoUser);
await _dbcontext.SaveChangesAsync();
}
public Task <TodoUser> CreateTodoUser()
{
var user_UserId = this._httpContextAcessor
.HttpContext
.User
.FindFirst(ClaimTypes.NameIdentifier).Value;
var user_UserName = this._httpContextAcessor
.HttpContext
.User
.FindFirst("preferred_username").Value;
var todoUserSet = this._dbcontext.Set <TodoUser>();
var todoUser = new TodoUser
{
UserId = user_UserId,
UserName = user_UserName
};
var result = todoUserSet.Add(todoUser);
var todoUserResult = this._dbcontext
.SaveChangesAsync()
.ContinueWith <TodoUser>((task) => result.Entity);
return(todoUserResult);
}
public async Task <IActionResult> Signup(AuthViewModel userData)
{
if (ModelState.IsValid)
{
var user = new TodoUser
{
Email = userData.Email,
UserName = userData.Email
};
var signupResult = await _userManager.CreateAsync(user, userData.Password);
if (signupResult.Succeeded)
{
var signInResult = await _signInManager.PasswordSignInAsync(user.UserName, userData.Password, true, false);
if (signInResult.Succeeded)
{
return(RedirectToAction("Todo", "Home"));
}
}
else
{
_logger.LogError("Failed to create user");
ModelState.AddModelError("", "Failed to sign up");
}
}
_logger.LogError("Failed to create user and sign up");
return(View());
}
public async Task <IActionResult> Signup([FromBody] CredentialModel model)
{
try
{
if (!ModelState.IsValid)
{
return(StatusCode(412));
}
var user = new TodoUser()
{
Email = model.Email, UserName = model.Email
};
var result = await _userMgr.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(await this.ReturnToken(user));
}
}
catch (Exception ex)
{
_logger.LogError($"Exception thrown while creating JWT: {ex}");
}
return(BadRequest("Failed to generate token"));
}
public IActionResult SetName(TodoUser user)
{
var todolist = new TodoList(user);
var jsonString = Newtonsoft.Json.JsonConvert.SerializeObject(todolist);
HttpContext.Response.Cookies.Append("userinfo", jsonString);
return(RedirectToAction("Index", "Home", new { area = "" }));
}
public TodoUser Put(int id, [FromBody] TodoUser TodoUser)
{
if (ModelState.IsValid)
{
TodoUser = _todoRepo.TodoUsers.Update(TodoUser);
_logger.Log(LogLevel.Information, this, LogFunction.Update, "TodoUser Updated {TodoUser}", TodoUser);
}
return(TodoUser);
}
private async Task <TodoUser> FindUser(string username)
{
await UpdateUserCache();
// It's a bit more user friendly to ingore case when searching.
TodoUser user = userCache.Find(u => u.username.Equals(username, StringComparison.InvariantCultureIgnoreCase));
return(user);
}
// [ProducesResponseType(StatusCodes.Status201Created)]
//[ProducesResponseType(StatusCodes.Status400BadRequest)]
public async Task <ActionResult <TodoUser> > PostTodoUser([FromQuery] TodoUser todoUser)
{
await Db.Connection.OpenAsync();
todoUser.Db = Db;
await todoUser.InsertAsync();
return(new OkObjectResult(todoUser));
}
public TodoUser Post([FromBody] TodoUser TodoUser)
{
if (ModelState.IsValid)
{
TodoUser = _todoRepo.TodoUsers.AddNew(TodoUser);
_logger.Log(LogLevel.Information, this, LogFunction.Create, "TodoUser Added {TodoUser}", TodoUser);
}
return(TodoUser);
}
public async Task <ActionResult> RequestUserByUsername(string username)
{
ViewBag.SyncType = "Asynchronous";
TodoUser user = await FindUser(username);
if (user == null)
{
return(Json(new { success = false, message = "User Not Found." }, JsonRequestBehavior.AllowGet));
}
return(Json(user, JsonRequestBehavior.AllowGet));
}
public async Task SeedData()
{
if (await _userManager.FindByNameAsync("afton") == null)
{
var aftonuser = new TodoUser()
{
UserName = "******",
Email = "*****@*****.**"
};
//password is hello2
var IdentityResult = await _userManager.CreateAsync(aftonuser, "Hello123!");
}
if (!_context.TodoList.Any())
{
_context.Add(new TodoList()
{
Todos = new List <Todo>
{
new Todo()
{
Name = "Dig in the garbage",
State = "Active",
DueDate = new DateTime(2016, 3, 23, 12, 0, 0),
Tags = new List <Tag> {
_dummyTag1, _dummyTag2
}
},
new Todo()
{
Name = "Question my life",
State = "Completed",
DueDate = new DateTime(2016, 3, 25, 12, 0, 0),
Tags = new List <Tag> {
_dummyTag3, _dummyTag4
}
},
new Todo()
{
Name = "Take over the world",
State = "Completed",
DueDate = new DateTime(2016, 3, 25, 12, 0, 0),
Tags = new List <Tag> {
},
}
},
WarningDays = 2
});
_context.SaveChanges();
}
}
public async Task SeedData()
{
if (await _userManager.FindByNameAsync("afton") == null)
{
var aftonuser = new TodoUser()
{
UserName = "******",
Email = "*****@*****.**"
};
//password is hello2
var IdentityResult = await _userManager.CreateAsync(aftonuser, "Hello123!");
}
if (!_context.TodoList.Any())
{
_context.Add(new TodoList()
{
Todos = new List<Todo>
{
new Todo()
{
Name = "Dig in the garbage",
State = "Active",
DueDate = new DateTime(2016, 3, 23, 12, 0, 0),
Tags = new List<Tag> {_dummyTag1, _dummyTag2}
},
new Todo()
{
Name = "Question my life",
State = "Completed",
DueDate = new DateTime(2016, 3, 25, 12, 0, 0),
Tags = new List<Tag> {_dummyTag3, _dummyTag4}
},
new Todo()
{
Name = "Take over the world",
State = "Completed",
DueDate = new DateTime(2016, 3, 25, 12, 0, 0),
Tags = new List<Tag> { },
}
},
WarningDays = 2
});
_context.SaveChanges();
}
}
protected async Task RefreshDMSUserAsync()
{
if (_moduleData.CurrentTodoUser != null)
{
return;
}
TodoUser dmsUser = null;
if (PageState.User != null)
{
dmsUser = await TodoApi.TodoUsers.GetByRouteAsync(current);
}
_moduleData.CurrentTodoUser = dmsUser;
}
protected override async Task <AuthenticateResult> HandleAuthenticateAsync()
{
if (!Request.Headers.ContainsKey("Authorization"))
{
return(AuthenticateResult.Fail("Authorization header was not found"));
}
try
{
var authenticationHeaderValue = AuthenticationHeaderValue.Parse(Request.Headers["Authorization"]);
var bytes = Convert.FromBase64String(authenticationHeaderValue.Parameter);
string[] credentials = Encoding.UTF8.GetString(bytes).Split(":");
string nick = credentials[0];
string password = credentials[1];
await Db.Connection.OpenAsync();
UserPostQuery query = new UserPostQuery(Db);
List <TodoUser> users = await query.LatestPostsAsync();
TodoUser user = users.Where(user => user.Nick == nick && user.Password == password).FirstOrDefault();
//TodoUser user = _context.TodoUsers.Where(user => user.Nick == nick && user.Password == password).FirstOrDefault();
if (user == null)
{
AuthenticateResult.Fail("Invalid nick or password");
}
else
{
var claims = new[] { new Claim(ClaimTypes.Name, user.Nick) };
var identity = new ClaimsIdentity(claims, Scheme.Name);
var principal = new ClaimsPrincipal(identity);
var ticket = new AuthenticationTicket(principal, Scheme.Name);
return(AuthenticateResult.Success(ticket));
}
}
catch (Exception e)
{
e.Message.ToString();
return(AuthenticateResult.Fail("Error has occurred"));
}
return(AuthenticateResult.Fail(""));
}
public async Task <IActionResult> PutTodoUser(String nick, String password, [FromQuery] TodoUser todoUser)
{
await Db.Connection.OpenAsync();
var query = new UserPostQuery(Db);
var result = await query.FindOneAsync(nick, password);
if (result is null)
{
return(new NotFoundResult());
}
result.Nick = todoUser.Nick;
await result.UpdateAsync();
JsonConvert.SerializeObject(result);
return(new OkObjectResult(result));
}
public async Task <ActionResult <TodoUser> > GetTodoUserAuth()
{
String nick = HttpContext.User.Identity.Name;
await Db.Connection.OpenAsync();
var query = new UserPostQuery(Db);
List <TodoUser> users = await query.LatestPostsAsync();
TodoUser user = users.Where(user => user.Nick == nick).FirstOrDefault();
if (user == null)
{
return(NotFound());
}
return(new OkObjectResult(user));
}
// ===============================================================================================
// Private methods
// ===============================================================================================
private async Task <IActionResult> updMainDataUserAsync(TodoUser objUser, UserVM updUser)
{
objUser.Name = updUser.Name;
objUser.Email = updUser.Email;
var resultUpd = await _userManager.UpdateAsync(objUser);
if (resultUpd.Succeeded)
{
return(Ok(new { Data = updUser, Status = "Success" }));
}
else
{
var firstError = resultUpd.Errors.FirstOrDefault();
_logger.LogError($"{firstError}");
return(BadRequest(new { Status = "Error", Error = firstError.Description, Errors = resultUpd.Errors }));
}
}
private TodoUser CreateNewTodoUser(ClaimsPrincipal user)
{
var currentUser = _tenantDB.User.AsNoTracking().FirstOrDefault(f => f.Username == user.Identity.Name);
var identityuser = _tenantDB.Users.AsNoTracking().FirstOrDefault(f => f.UserName == user.Identity.Name);
var newTodoUser = new TodoUser
{
AppUserId = currentUser.UserId,
AspNetUserId = identityuser.Id,
Email = identityuser.Email,
NormalizedEmail = identityuser.NormalizedEmail,
Username = identityuser.UserName,
NormalizedUserName = identityuser.NormalizedUserName,
DisplayName = identityuser.UserName
};
newTodoUser = _todoRepo.TodoUsers.AddNew(newTodoUser);
return(newTodoUser);
}
/// <summary>
/// 通过OpenId获取UserId
/// </summary>
/// <param name="openId"></param>
/// <returns></returns>
private Guid getUserId(string openId)
{
try
{
if (string.IsNullOrEmpty(openId))
{
throw new ArgumentNullException("OpenId为空");
}
var user = (from u in _todoContext.TodoUsers
where !string.IsNullOrEmpty(u.OpenId) && u.OpenId == openId
select u).FirstOrDefault();
if (user == null)
{
//未注册，进行注册
user = new TodoUser()
{
TodoUserId = Guid.NewGuid(),
OpenId = openId
};
_todoContext.TodoUsers.Add(user);
_todoContext.SaveChanges();
return(user.TodoUserId);
}
else
{
//已注册，返回UserId
return(user.TodoUserId);
}
}
catch (Exception ex)
{
logger.Error(ex);
logger.Error(ex.InnerException);
throw;
}
}
public async Task <IActionResult> CreatingUser([FromBody] UserVM newUser)
{
try
{
if (await _userManager.FindByEmailAsync(newUser.Email) == null)
{
TodoUser objUser = new TodoUser()
{
Name = newUser.Name,
UserName = newUser.Email,
Email = newUser.Email,
};
IdentityResult objIdentRes = await _userManager.CreateAsync(objUser, newUser.Password);
if (objIdentRes.Succeeded)
{
string pwd = newUser.Password;
newUser.Id = objUser.Id;
newUser.Password = null;
// return result
return(Ok(new { Data = newUser, Status = "Success" }));
}
else
{
return(BadRequest(new { Status = "Error", Error = objIdentRes.Errors.FirstOrDefault().Description, Errors = objIdentRes.Errors }));
}
}
else
{
throw new Exception("The e-mail is registered");
}
}
catch (Exception ex)
{
_logger.LogError($"{ex.Message}");
return(BadRequest(new { Status = "Error", Error = $"{ex.Message}" }));
}
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
if (ModelState.IsValid)
{
var profile = await Gravatar.GetProfile(Gravatar.GetHash(Input.Email));
var user = new TodoUser {
UserName = Input.Email, Email = Input.Email, Name = profile.displayName
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { userId = user.Id, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <IActionResult> UpdateUser(UserVM updUser, string newPassword)
{
try
{
TodoUser objUser = _repository.GetUsers().Where(u => u.Id == updUser.Id).FirstOrDefault <TodoUser>();
if (objUser == null)
{
return(BadRequest(new { Status = "Error", Error = "The user doesn't exists" }));
}
if (updUser.Password != null)
{
var resultChangePsw = await _userManager.ChangePasswordAsync(objUser, updUser.Password, newPassword);
if (resultChangePsw.Succeeded)
{
updUser.Password = null;
return(await updMainDataUserAsync(objUser, updUser));
}
else
{
var firstError = resultChangePsw.Errors.FirstOrDefault();
_logger.LogError($"{firstError}");
return(BadRequest(new { Status = "Error", Error = firstError.Description, Errors = resultChangePsw.Errors }));
}
}
else
{
return(await updMainDataUserAsync(objUser, updUser));
}
}
catch (Exception ex)
{
_logger.LogError($"{ex.Message}");
return(BadRequest(new { Status = "Error", Error = $"{ex.Message}" }));
}
}
public async Task <IActionResult> UserById(int userId)
{
try
{
UserVM result = null;
await Task.Run(() =>
{
TodoUser tdUser = _repository.GetUsers().Where(u => u.Id == userId).FirstOrDefault <TodoUser>();
result = new UserVM()
{
Id = tdUser.Id,
Name = tdUser.Name,
Email = tdUser.Email
};
});
return(Ok(result));
}
catch (Exception ex)
{
_logger.LogError($"{ex.Message}");
return(BadRequest(new { Status = "Error", Error = $"{ex.Message}" }));
}
}
public TodoList(TodoUser owner, string title)
{
Owner = owner;
Title = title;
}
