public async Task InvokeAsync(HttpContext context)
{
if (!String.IsNullOrEmpty(context.User.Identity.Name))
{
ClaimsPrincipal userClaims = context.User;
Claim getHash_mongoDocumentId = userClaims.Claims.Where(r => r.Type == ClaimTypes.Hash).FirstOrDefault();
if (getHash_mongoDocumentId != null)
{
string mongoDocumentId = getHash_mongoDocumentId.Value;
AuthorizationDTO Authorization = _authorizationController.Read(mongoDocumentId);
if (Authorization != null)
{
var claims = new List <Claim>
{
new Claim(ClaimTypes.Role, Authorization.Role)
};
ClaimsIdentity claimsIdentityRole = new ClaimsIdentity(claims);
userClaims.AddIdentity(claimsIdentityRole);
}
}
}
await _next(context);
}
public void Update(AuthorizationDTO f)
{
var f1 = authorizationRepository.GetAll()
.Where(p => p.IDAdmin == f.IDAdmin && p.IDCN == f.IDCN)
.FirstOrDefault();
f.Mapping(f1);
authorizationRepository.Update(f1);
}
public static AuthorizationDTO MappingDto(this Authorization f1)
{
var f = new AuthorizationDTO
{
IDAdmin = f1.IDAdmin,
IDCN = f1.IDCN,
};
return(f);
}
public static Authorization Mapping(this AuthorizationDTO f)
{
var f1 = new Authorization
{
IDAdmin = f.IDAdmin,
IDCN = f.IDCN
};
return(f1);
}
public void RemoveByIDCN(AuthorizationDTO authorizationDTO)
{
var authors = authorizationRepository.GetAll();
foreach (var item in authors)
{
if (item.IDCN == authorizationDTO.IDCN)
{
authorizationRepository.Delete(item);
}
}
}
public IHttpActionResult CheckToken(AuthorizationDTO authorization)
{
try
{
if (JWTAuthenticate.Instance().IsValid(authorization.IdToken))
{
return(StatusCode(HttpStatusCode.NoContent));
}
else
{
return(Unauthorized());
}
}
catch
{
return(InternalServerError());
}
}
public async Task <IHttpActionResult> GetAccessToken([FromBody] CredentialDTO credential, [FromUri] string scope = null)
{
string userName = credential.UserName;
string password = credential.Password;
try
{
bool isValidUser = await Authentication.CheckAuthenticateAsync(userName, password, DOMAIN_NAME);
if (!isValidUser)
{
return(Unauthorized());
}
AuthorizationDTO authorization = null;
if (string.Equals(scope, "none", StringComparison.OrdinalIgnoreCase))
{
authorization = new AuthorizationDTO
{
IdToken = JWTAuthenticate.Instance().GetBasicToken(userName)
};
}
else
{
UserDetail user = await Authentication.GetUserEmailFromADAsync(userName, password, DOMAIN_NAME);
authorization = new AuthorizationDTO
{
IdToken = JWTAuthenticate.Instance().GetDetailedToken(userName, user.EmailAddress, user.Name)
};
}
return(Ok(authorization));
}
catch
{
return(InternalServerError());
}
}
public async Task <IActionResult> Login(UserSignDTO userSignDTO)
{
if (ModelState.IsValid)
{
JObject datasJson = await _userServices.Login(userSignDTO);
if (datasJson["error"] is null)
{
AuthorizationDTO authorization = JsonHelper.Deserialize <AuthorizationDTO>(datasJson.ToString());
UserClaimDTO userClaim = await _authenticationService.AcquireUserClaim(_serverAddresses.Addresses.FirstOrDefault(), authorization.access_token);
if (authorization is null || userClaim is null)
{
return(StatusCode(500));
}
var loginStatus = _mapper.Map <LoginStatusDTO>(userSignDTO);
_mapper.Map(userClaim, loginStatus);
_mapper.Map <AuthorizationDTO, LoginStatusDTO>(authorization, loginStatus);
return(Ok(new ResponseCtrMsg <LoginStatusDTO>(CtrResult.Success)
{
ResultObj = loginStatus
}));
}
else
{
this._logger.LogInformation("User:"******",Login Control failed");
return(BadRequest("账号密码错误"));
}
}
else
{
this._logger.LogInformation("The passed in model is empty");
return(BadRequest(new ResponseCtrMsg <object>(CtrResult.Failure)
{
message = "传入的模型为空"
}));
}
}
public async Task <AuthorizationResultDTO> LoginAsync(AuthorizationDTO model)
{
var authorizationResult = new AuthorizationResultDTO();
var result = await _unitOfWork.SignInManager.PasswordSignInAsync(model.UserName, model.Password, false, false);
authorizationResult.Succeded = result.Succeeded;
if (result.Succeeded)
{
var appUser = await _unitOfWork.UserManager.FindByNameAsync(model.UserName);
appUser.RefreshToken = appUser.RefreshToken ?? _tokenService.GenerateRefreshToken();
authorizationResult.Token = await _tokenService.GenerateJwtToken(appUser.UserName, appUser.Id);
authorizationResult.Token.RefreshToken = appUser.RefreshToken;
await _unitOfWork.SaveAsync();
}
return(authorizationResult);
}
public void Create(AuthorizationDTO f1)
{
var f = f1.Mapping();
authorizationRepository.Add(f);
}
public void Update(string Id, AuthorizationDTO authorization)
{
_authorizations.ReplaceOne(Builders <AuthorizationDTO> .Filter.Eq("Id", Id), authorization);
}
public string Create(AuthorizationDTO authorization)
{
authorization.Id = ObjectId.GenerateNewId().ToString();
_authorizations.InsertOne(authorization);
return(authorization.Id.ToString());
}
public void Update(string Id, AuthorizationDTO authorization)
{
authorizationRepository.Update(Id, authorization);
}
public string Create(AuthorizationDTO authorization)
{
return(authorizationRepository.Create(authorization));
}
public static void Mapping(this AuthorizationDTO f, Authorization f1)
{
f1.IDAdmin = f.IDAdmin;
f1.IDCN = f.IDCN;
}
