public async Task <ActionResult <ActiveCompanyResult> > ValidateForDepartment([FromBody] SetActiveComapnyInput authInput)
{
if (this.ModelState.IsValid)
{
if (authInput == null)
{
return(BadRequest());
}
var signInResult = await _signInManager.PasswordSignInAsync(authInput.Usr, authInput.Pass, true, lockoutOnFailure : false);
if (signInResult.Succeeded)
{
if (await _usersService.DoesUserHaveAnyActiveDepartments(authInput.Usr))
{
var user = await _usersService.GetUserByNameAsync(authInput.Usr);
if (await _departmentsService.IsMemberOfDepartmentAsync(authInput.Did, user.Id))
{
Department department = await _departmentsService.GetDepartmentForUserAsync(authInput.Usr);
var result = new ActiveCompanyResult
{
Eml = user.Email,
Uid = user.Id,
Dnm = department.Name,
Did = department.DepartmentId
};
if (department.CreatedOn.HasValue)
{
result.Dcd = (department.CreatedOn.Value - new DateTime(1970, 1, 1).ToLocalTime())
.TotalSeconds.ToString();
}
else
{
result.Dcd = new DateTime(1970, 1, 1).ToLocalTime().ToString();
}
result.Tkn = V3AuthToken.Create(authInput.Usr, authInput.Did);
result.Txd = DateTime.UtcNow.AddMonths(Config.SystemBehaviorConfig.APITokenMonthsTTL)
.ToShortDateString();
var profile = await _userProfileService.GetProfileByUserIdAsync(user.Id);
result.Nme = profile.FullName.AsFirstNameLastName;
return(Ok(result));
}
}
}
return(Unauthorized());
}
return(BadRequest());
}
public ActiveCompanyResult ValidateForDepartment([FromBody] SetActiveComapnyInput authInput)
{
if (this.ModelState.IsValid)
{
if (authInput == null)
{
throw HttpStatusCode.BadRequest.AsException();
}
// Hack while services is migrated to DotNetCore and can utilize the underlying calls
var client = new RestClient(Config.SystemBehaviorConfig.ResgridBaseUrl);
var request = new RestRequest($"/CoreBridge/ValidateLogIn", Method.POST);
request.AddJsonBody(authInput);
var response = client.Execute <Model.Results.ValidateLogInResult>(request);
if (response.Data == null || !response.Data.Successful)
{
throw HttpStatusCode.Unauthorized.AsException();
}
var user = _usersService.GetUserByName(authInput.Usr);
if (_departmentsService.IsMemberOfDepartment(authInput.Did, user.Id))
{
Department department = _departmentsService.GetDepartmentForUser(authInput.Usr);
var result = new ActiveCompanyResult
{
Eml = user.Email,
Uid = user.Id,
Dnm = department.Name,
Did = department.DepartmentId
};
if (department.CreatedOn.HasValue)
{
result.Dcd = (department.CreatedOn.Value - new DateTime(1970, 1, 1).ToLocalTime()).TotalSeconds.ToString();
}
else
{
result.Dcd = new DateTime(1970, 1, 1).ToLocalTime().ToString();
}
result.Tkn = V3AuthToken.Create(authInput.Usr, authInput.Did);
result.Txd = DateTime.UtcNow.AddMonths(Config.SystemBehaviorConfig.APITokenMonthsTTL).ToShortDateString();
var profile = _userProfileService.GetProfileByUserId(user.Id);
result.Nme = profile.FullName.AsFirstNameLastName;
return(result);
}
throw HttpStatusCode.Unauthorized.AsException();
}
throw HttpStatusCode.BadRequest.AsException();
}
public static async Task <bool> AuthAndSetPrinciple(ICacheProvider cacheProvider, IDepartmentsRepository departmentsRepository, string authTokenString)
{
if (string.IsNullOrWhiteSpace(authTokenString))
{
return(false);
}
var encodedUserPass = authTokenString.Trim();
var authToken = V3AuthToken.Decode(encodedUserPass);
if (authToken != null)
{
string userId;
if (Config.SecurityConfig.SystemLoginCredentials.ContainsKey(authToken.UserName))
{
if (Config.SecurityConfig.SystemLoginCredentials[authToken.UserName] != encodedUserPass)
{
return(false);
}
authToken.UserId = authToken.UserName;
}
else
{
var result = await ValidateUserAndDepartmentByUser(cacheProvider, departmentsRepository, authToken.UserName, authToken.DepartmentId, null);
if (!result.IsValid)
{
return(false);
}
authToken.UserId = result.UserId;
}
//var principal = new ResgridPrincipleV3(authToken);
//Thread.CurrentPrincipal = principal;
//if (context != null)
//{
// context.User = new System.Security.Claims.ClaimsPrincipal(principal);
//}
}
return(true);
}
protected override async Task <AuthenticateResult> HandleAuthenticateAsync()
{
var endpoint = Context.GetEndpoint();
if (endpoint?.Metadata?.GetMetadata <IAllowAnonymous>() != null)
{
return(AuthenticateResult.NoResult());
}
if (!Request.Headers.ContainsKey("Authorization"))
{
return(AuthenticateResult.Fail("Missing Authorization Header"));
}
try
{
var authHeader = AuthenticationHeaderValue.Parse(Request.Headers["Authorization"]);
var result = await AuthAndSetPrinciple(_cacheProvider, _departmentRepository, authHeader.Parameter);
if (!result)
{
return(AuthenticateResult.Fail("Invalid Authorization Header"));
}
var authToken = V3AuthToken.Decode(authHeader.Parameter);
var user = await _usersService.GetUserByNameAsync(authToken.UserName);
var principal = await _claimsPrincipalFactory.CreateAsync(user);
Thread.CurrentPrincipal = principal;
Context.User = principal;
var ticket = new AuthenticationTicket(principal, Scheme.Name);
return(AuthenticateResult.Success(ticket));
}
catch
{
return(AuthenticateResult.Fail("Invalid Authorization Header"));
}
}
