public async Task <IActionResult> PutAspNetUserTokens(string id, AspNetUserTokens aspNetUserTokens)
{
if (id != aspNetUserTokens.UserId)
{
return(BadRequest());
}
_context.Entry(aspNetUserTokens).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AspNetUserTokensExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> Edit(int id, [Bind("Id,UserId,LoginProvider,Name,Value")] AspNetUserTokens aspNetUserTokens)
{
if (id != aspNetUserTokens.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(aspNetUserTokens);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AspNetUserTokensExists(aspNetUserTokens.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["UserId"] = new SelectList(_context.AspNetUsers, "Id", "Id", aspNetUserTokens.UserId);
return(View(aspNetUserTokens));
}
public Task <IActionResult> Edit(AspNetUserTokens model)
{
return(Task.Factory.StartNew <IActionResult>(() =>
{
if (!ModelState.IsValid)
{
return Json(ExcutedResult.FailedResult("数据验证失败"));
}
AspNetUserTokensRepository.Edit(model, false);
return Json(ExcutedResult.SuccessResult());
}));
}
public async Task <IActionResult> Create([Bind("Id,UserId,LoginProvider,Name,Value")] AspNetUserTokens aspNetUserTokens)
{
if (ModelState.IsValid)
{
_context.Add(aspNetUserTokens);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["UserId"] = new SelectList(_context.AspNetUsers, "Id", "Id", aspNetUserTokens.UserId);
return(View(aspNetUserTokens));
}
public async Task <IActionResult> addToken(string token, string id)
{
TokenDatabaseContext table = new TokenDatabaseContext();
AspNetUserTokens tokenUser = new AspNetUserTokens();
tokenUser.UserId = id;
tokenUser.Value = token;
await table.AspNetUserTokens.AddAsync(tokenUser);
await table.SaveChangesAsync();
return(Ok());
}
public async Task <ActionResult <AspNetUserTokens> > PostAspNetUserTokens(AspNetUserTokens aspNetUserTokens)
{
_context.AspNetUserTokens.Add(aspNetUserTokens);
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (AspNetUserTokensExists(aspNetUserTokens.UserId))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtAction("GetAspNetUserTokens", new { id = aspNetUserTokens.UserId }, aspNetUserTokens));
}
public virtual async Task SetAuthenticatorKeyAsync(TUser user, string key, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
user.ConcurrencyStamp = user.ConcurrencyStamp ?? $"{Guid.NewGuid()}";
_connection.SetTypeInfo(typeof(AspNetUserTokens <TKey>));
var exists = SqlBuilder.Select <AspNetUserTokens <TKey> >(new
{
TenantId = _tenantId,
UserId = user.Id,
Name = "AuthenticatorKey",
LoginProvider = "[AspNetUserStore]"
});
var token = await _connection.Current.QuerySingleOrDefaultAsync <AspNetUserTokens <TKey> >(exists.Sql,
exists.Parameters);
if (string.IsNullOrWhiteSpace(token.Value))
{
token = new AspNetUserTokens <TKey>
{
TenantId = _tenantId,
UserId = user.Id,
LoginProvider = "[AspNetUserStore]",
Name = "AuthenticatorKey",
Value = key
};
var query = SqlBuilder.Insert(token);
await _connection.Current.ExecuteAsync(query.Sql, query.Parameters);
}
else
{
var query = SqlBuilder.Update(token, new { UserId = user.Id, TenantId = _tenantId });
await _connection.Current.ExecuteAsync(query.Sql, query.Parameters);
}
}
public string AuthorizeResetPassword(string email)
{
if (string.IsNullOrEmpty(email))
{
return("");
}
var user = _repo.GetActive().Where(p => p.Email == email).FirstOrDefault();
if (user == null)
{
return(null);
}
var token = CreateToken(email);
var userToken = _aspNetUserTokensRepo.Get().Where(p => p.UserId == user.Id && p.Name == user.Name).FirstOrDefault();
if (userToken == null)
{
userToken = new AspNetUserTokens()
{
UserId = user.Id,
Value = token,
Name = user.Name,
LoginProvider = CreateToken(token)
};
_aspNetUserTokensRepo.Create(userToken);
}
else
{
userToken.Value = token;
_aspNetUserTokensRepo.Update(userToken);
}
_aspNetUserTokensRepo.SaveChanges();
return(token);
}
public AspNetUserTokenShould()
{
_userTokens = new AspNetUserTokens();
}
public override AccountServiceModel Create(AuthorizeRegisterModel requestModel)
{
try
{
// Check existed email
var existAccount = _repo.GetActive().Where(p => p.Email == requestModel.Email).FirstOrDefault();
if (existAccount != null)
{
return(null);
}
// Check Administrator / BrandManager / Employee Register
if (requestModel.ManagerRegistrationToken == "token_v2_7/2019")
{
if (requestModel.IsAdmin)
{
requestModel.Role = 2;
}
else
{
requestModel.Role = 3;
}
}
else
{
requestModel.Role = 1;
}
// Create AspNetUser
UniLogUtil utils = new UniLogUtil();
var accountNetUser = Mapper.Map <AuthorizeRegisterModel, AspNetUsersCreateRequestModel>(requestModel);
accountNetUser.PasswordHash = utils.GetMd5HashData(requestModel.Password);
accountNetUser.NormalizedUserName = accountNetUser.Name.ToUpper();
accountNetUser.NormalizedEmail = accountNetUser.Email.ToUpper();
accountNetUser.NormalizedUserName = accountNetUser.Name.ToUpper();
accountNetUser.PhoneNumber = requestModel.Phone;
var aspNetUser = _aspNetUsersService.Create(accountNetUser);
// Create AspNetUserTokens
AspNetUserTokens aspToken = new AspNetUserTokens()
{
UserId = aspNetUser.Id,
Name = aspNetUser.Name,
LoginProvider = _aspNetUsersService.CreateToken(aspNetUser.Email)
};
_aspNetUserTokensRepo.Create(aspToken);
_aspNetUserTokensRepo.SaveChanges();
// Create AspNetUsersRoles
AspNetUserRoles aspUserRoles = new AspNetUserRoles()
{
UserId = aspNetUser.Id,
RoleId = requestModel.Role
};
_aspNetUserRolesRepository.Create(aspUserRoles);
_aspNetUserRolesRepository.SaveChanges();
// Create Account
var account = Mapper.Map <AuthorizeRegisterModel, Account>(requestModel);
account.AspNetUserId = aspNetUser.Id;
_repo.Create(account);
_repo.SaveChanges();
return(Mapper.Map <Account, AccountServiceModel>(account));
}
catch (Exception)
{
throw;
}
}
