public async Task <IActionResult> PutAuthorization(long id, AuthorizationDto authorizationDto)
{
if (id != authorizationDto.Id)
{
return(BadRequest());
}
var authorization = await _context.Authorizations.FindAsync(id);
authorization.IsGlobal = authorizationDto.IsGlobal;
authorization.Name = authorizationDto.Name;
authorization.CanEdit = authorizationDto.CanEdit;
_context.Entry(authorization).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!AuthorizationExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task ValidateToken_CorrectToken_ResponseSuccessStatusAsync(NewUserDto data)
{
await Task.Delay(1000);
data.Username = data.Password = data.Username + "cheburek";
var client = Factory.CreateClient();
await UserCreator.CreateUserAsync(Factory, _contentProvider, data, client);
var authData = new AuthorizationDto
{
Username = data.Username,
Password = data.Password
};
var getTokenPath = GetControllerActionPath("GetToken");
var validatePath = GetControllerActionPath("ValidateToken");
var authDataContent = _contentProvider.GetJsonStringContent(authData);
var response = await client.PostAsync(getTokenPath, authDataContent);
response.EnsureSuccessStatusCode();
var result = await response.Content.ReadAsAsync <TokenDto>();
var query = $"?token={result.access_token}";
response = await client.GetAsync(validatePath + query);
response.EnsureSuccessStatusCode();
}
public async Task <IActionResult> UserAuthorize([FromBody] AuthorizationDto authorizationDto)
{
try
{
var user = await _workWithUser.CheckUserForm(authorizationDto);
if (user == null)
{
return(NotFound("Wrong password"));
}
var encodedJwt = JwtGenerator.GenerateJwt(user);
var response = new
{
access_token = encodedJwt
};
return(new JsonResult(response));
}
catch (ArgumentException ex)
{
return(NotFound(ex.Message));
}
catch (Exception ex)
{
return(Problem(ex.Message));
}
}
public async Task <Object> Login([FromBody] AuthorizationDto authorizationDto)
{
if (!string.IsNullOrEmpty(authorizationDto.Email) && !string.IsNullOrEmpty(authorizationDto.Password))
{
var normalizedEmail = authorizationDto.Email.Trim();
var user = await _userManager.FindByEmailAsync(normalizedEmail);
if (user != null)
{
var result = await _signInManager.PasswordSignInAsync(user.UserName,
authorizationDto.Password, true, false);
if (result.Succeeded)
{
var token = await GenerateJwtToken(authorizationDto.Email, user);
var userDto = _mapper.Map <User, UserDto>(user);
return(new
{
token,
user = userDto
});
}
}
return(BadRequest("Неверный email и (или) пароль"));
}
return(BadRequest("Заполните все поля"));
}
public void Add(AuthorizationDto authorizationDto)
{
if (authorizationRepository.FindAll().Any(x => x.LockId == authorizationDto.Lock.Id && (x.DigitalKeyId == authorizationDto.User.Key.Id && x.IsActive || (!x.IsActive && !x.EndDate.HasValue))))
{
return;
}
var authorization = Authorization.Create(authorizationDto.Lock.Id, authorizationDto.User.Key.Id, authorizationDto.IsActive);
authorizationRepository.Add(authorization);
}
public async Task <ActionResult <AuthorizationDto> > PostAuthorization(AuthorizationDto authorization)
{
_context.Authorizations.Add(new Authorization
{
Name = authorization.Name,
IsGlobal = authorization.IsGlobal,
CanEdit = authorization.CanEdit
});
await _context.SaveChangesAsync();
return(CreatedAtAction("GetAuthorization", new { id = authorization.Id }, authorization));
}
public async Task <IActionResult> TokenAsync(AuthorizationDto authData)
{
var isAuthorized = await _authService.AuthorizeAsync(authData.Username, authData.Password);
if (!isAuthorized)
{
return(Unauthorized());
}
var token = _jwtTokenService.GenerateToken(authData.Username);
return(Ok(token));
}
public async Task <UserDto> CheckUserForm(AuthorizationDto authorizationDto)
{
if ((await _unitOfWork.Users.GetAll()).Count(u => u.Login == authorizationDto.Login) == 0)
{
throw new ArgumentException("User is undefined");
}
if ((await _unitOfWork.Users.GetAll()).First(u => u.Login == authorizationDto.Login).Password ==
Hashing.GetHashString(authorizationDto.Password))
{
return(_mapper.Map <UserDto>(
(await _unitOfWork.Users.GetAll()).First(u => u.Login == authorizationDto.Login)));
}
return(null);
}
public virtual IList <AuthorizationDto> queryAuthorizations(AuthorizationQueryDto queryDto, int?firstResult, int?maxResults)
{
queryDto.ObjectMapper = ObjectMapper;
AuthorizationQuery query = queryDto.toQuery(ProcessEngine);
IList <Authorization> resultList;
if (firstResult != null || maxResults != null)
{
resultList = executePaginatedQuery(query, firstResult, maxResults);
}
else
{
resultList = query.list();
}
return(AuthorizationDto.fromAuthorizationList(resultList, processEngine.ProcessEngineConfiguration));
}
private async Task <TokenDto> GetToken(NewUserDto data)
{
await UserCreator.CreateUserAsync(Factory, _contentProvider, data, Client);
var authData = new AuthorizationDto
{
Username = data.Username,
Password = data.Password
};
var getTokenPath = GetControllerActionPath("GetToken");
var authDataContent = _contentProvider.GetJsonStringContent(authData);
var response = await Client.PostAsync(getTokenPath, authDataContent);
response.EnsureSuccessStatusCode();
var result = await response.Content.ReadAsAsync <TokenDto>();
return(result);
}
public static async Task CreateUserAsync(WebApplicationFactory <Startup> factory, ContentProvider contentProvider, NewUserDto data, HttpClient client)
{
var isUserExists = await IsUserExists(data, factory);
if (!isUserExists)
{
await SendPostRequestAndSetTokenHeader(contentProvider, data, client, "user");
return;
}
var authData = new AuthorizationDto()
{
Password = data.Password,
Username = data.Username
};
await SendPostRequestAndSetTokenHeader(contentProvider, authData, client, "auth/GetToken");
}
public async Task CheckForm_RepositoryInvokes()
{
//Arrange
_userRepositoryMock.Setup(r => r.GetAll())
.ReturnsAsync(_fakeData.Users);
var user = _fakeData.Users.Last();
var authDto = new AuthorizationDto
{
Login = user.Login,
Password = user.Password.ToString()
};
//Act
await _userService.CheckUserForm(authDto);
//Assert
_userRepositoryMock.Verify(r => r.GetAll());
_unitOfWorkMock.Verify(uow => uow.Users);
}
/// <summary>
/// 驗証是否符合 CustomAuthorizeAttribute 資格
/// </summary>
private void ValidateCustomAuthorize(ControllerContext controllerContext, string actionName)
{
var controllerDescriptor = GetControllerDescriptor(controllerContext);
var actionDescriptor = FindAction(controllerContext, controllerDescriptor, actionName)
?? controllerDescriptor.GetCanonicalActions()
.FirstOrDefault(a => a.ActionName == actionName);
var attributeRoles = controllerDescriptor.GetControllerCustomAttributes()
.Concat(actionDescriptor.GetActionCustomAttributes())
.Distinct()
.ToArray();
if (attributeRoles.Length > 0 == false)
{
return;
}
if (_userDto == null)
{
throw new CustomException("No Authentication")
{
ErrorCode = HttpStatusCode.Unauthorized
};
}
var authorizeRepository = DiResolver.GetService <IAuthorizeRepository>();
var dto = new AuthorizationDto
{
UserId = _userDto.UserId,
AttributeRoles = attributeRoles
};
if (authorizeRepository.Auth(dto) == false)
{
throw new CustomException("Authorizted Failed")
{
ErrorCode = HttpStatusCode.Unauthorized,
IsAuthenticated = _userDto != null
};
}
}
public async Task <AuthorizationDto> Execute(string username, string password)
{
try
{
var user = await _getByUserNameAndPasswordUserUseCase.Execute(username, password);
if (user == null)
{
throw new TOTVSCustomExcepetion(System.Net.HttpStatusCode.NotFound, "Invalid Credentials");
}
string token = await _generateAuthorizationTokenUseCase.Execute(user);
return(AuthorizationDto.Create(user, token));
}
catch (TOTVSCustomExcepetion ex)
{
throw ex;
}
}
public bool Auth(AuthorizationDto dto)
{
var sqlScript = $"EXECUTE {SpStore.AuthorizeUserIdRoles} @userId, @attributeRoles";
var parameters = new DynamicParameters();
parameters.Add("userId", dto.UserId, DbType.Int32);
var attributeRolesDataTable = new DataTableStringWithSerialGenerator("Value");
attributeRolesDataTable.AddRange(dto.AttributeRoles);
parameters.Add("attributeRoles", attributeRolesDataTable.Result.AsTableValuedParameter("[dbo].[Nvarchar1000]"));
using (var conn = new SqlConnection(ConnectionString))
{
var result = conn.Query <AuthResultDto>(sqlScript, parameters)
.FirstOrDefault(r => r.UserId == dto.UserId)
?.AuthResult;
return(result ?? false);
}
}
public static PostAuthenticateResponse Translate(AuthorizationDto dto) => dto != null?PostAuthenticateResponse.Create(dto.User, dto.Token) : PostAuthenticateResponse.Create();
public IActionResult Index(IFormCollection avm)
{
LoadData();
var newAuth = new AuthorizationDto();
newAuth.IsActive = true;
foreach (var key in avm.Keys)
{
var val = avm[key];
try
{
switch (key)
{
case "SelectedUserName":
newAuth.User = Users.First(m => (m.FirstName + " " + m.LastName).Equals((string)val));
break;
case "SelectedLockName":
newAuth.Lock = Locks.First(m => m.Name.Equals((string)val));
break;
case "StartDate":
{
Regex rex = new Regex("(\\d+)-(\\d+)-(\\d+)T(\\d+):(\\d+):(\\d+).(\\d+).(.*)");
var matches = rex.Matches((string)val);
var match = matches[0];
newAuth.StartDate = new DateTime(int.Parse(match.Groups[1].Value),
int.Parse(match.Groups[2].Value),
int.Parse(match.Groups[3].Value),
int.Parse(match.Groups[4].Value),
int.Parse(match.Groups[5].Value),
int.Parse(match.Groups[6].Value));
}
break;
case "EndDate":
if (!string.IsNullOrEmpty(val))
{
Regex rex = new Regex("(\\d+)-(\\d+)-(\\d+)T(\\d+):(\\d+):(\\d+).(\\d+).(.*)");
var matches = rex.Matches((string)val);
var match = matches[0];
newAuth.StartDate = new DateTime(int.Parse(match.Groups[1].Value),
int.Parse(match.Groups[2].Value),
int.Parse(match.Groups[3].Value),
int.Parse(match.Groups[4].Value),
int.Parse(match.Groups[5].Value),
int.Parse(match.Groups[6].Value));
}
break;
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + "\n" + ex.StackTrace);
}
}
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(ApiBaseAddress);
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var rawContent = JsonConvert.SerializeObject(newAuth);
HttpContent content = new ByteArrayContent(Encoding.UTF8.GetBytes(rawContent));
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
try
{
var result = client.PostAsync("api/authorization", content).Result;
}
catch (Exception ex)
{
Console.WriteLine(DateTime.Now + ": (AuthorizationViewController) : (Index) : " + ex.Message + "\n" + ex.StackTrace);
}
}
return(Index());
}
public void Post([FromBody] AuthorizationDto authorizationDto)
{
authorizationService.Add(authorizationDto);
}
