public IActionResult Connect(
[FromBody] CredentialsDTO dto,
[FromQuery] bool stayConnected = false
)
{
ISession session = HttpContext.Session;
if (!String.IsNullOrEmpty(session.GetString(SessionHandler.CREDENTIALS_KEY)))
{
throw new AppException("A connection is still enabled", 400);
}
object ret = CredentialsHandler.SetAndCheck(dto);
if (stayConnected)
{
var cookieOptions = new CookieOptions()
{
IsEssential = true
};
Action <string, string> addCookie = (key, value) =>
HttpContext.Response.Cookies.Append(key, value, cookieOptions);
addCookie(USER_TYPE_KEY, $"{CredentialsHandler.GetUserType}");
addCookie(ID_KEY, $"{CredentialsHandler.GetId}");
addCookie(PASSWORD_KEY, $"{CredentialsHandler.GetPassword}");
}
session.SetString(SessionHandler.CREDENTIALS_KEY, CredentialsHandler.GetString);
return(Ok(ret));
}
public async Task <IHttpActionResult> Authenticate(CredentialsDTO credentials)
{
Fr8AccountDO account;
TerminalDO terminalDO;
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
terminalDO = _terminal.GetByNameAndVersion(credentials.Terminal.Name, credentials.Terminal.Version);
account = _security.GetCurrentAccount(uow);
}
var response = await _authorization.AuthenticateInternal(
account,
terminalDO,
credentials.Domain,
credentials.Username,
credentials.Password,
credentials.IsDemoAccount
);
return(Ok(new TokenResponseDTO
{
TerminalId = response.AuthorizationToken?.TerminalID,
TerminalName = terminalDO.Name,
AuthTokenId = response.AuthorizationToken?.Id.ToString(),
Error = response.Error
}));
}
public async Task <(string token, DateTime expiration)> CreateJWT(CredentialsDTO credentials)
{
try
{
var user = await _context.Users.FirstOrDefaultAsync(c => c.Email == credentials.Email);
if (user != null)
{
var(verified, needsUpgrade) = _pwHasher.Check(user.Password, credentials.Password);
if (verified)
{
if (needsUpgrade)
{
user.Password = _pwHasher.Hash(credentials.Password);
await _context.SaveChangesAsync();
}
return(_tokenHelper.GenerateJWT(user.Id, user.Email));
}
}
return(null, DateTime.MinValue);
}
catch
{
throw;
}
}
public async Task <Response <AuthInfoDTO> > Authenticate(CredentialsDTO request)
{
var user = await _provider.GetUserDetail(request.Email);
if (user.Data == null)
{
return(new SecurityErrorResponse <AuthInfoDTO>()
{
Code = ErrorCodes.Security.AuthDataInvalid,
Message = ErrorMessages.Security.AuthDataInvalid,
});
}
if (user.Data.RoleId != RoleGuid.Admin)
{
return(new SecurityErrorResponse <AuthInfoDTO>()
{
Code = ErrorCodes.Security.AuthDataInvalid,
Message = ErrorMessages.Security.AuthDataInvalid,
});
}
var result = await _tokensService.Authenticate(request);
return(result);
}
public async Task <NewsDTO> GetNews(CredentialsDTO credentials)
{
string text = GetContentFromEmail(credentials.EmailUsername, credentials.EmailPassword, credentials.EmailSenderFilter);
NewsDTO news = GetNews(text);
return(news);
}
public async Task <IActionResult> Post([FromBody] CredentialsDTO credentials)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var identity = await GetClaimsIdentity(credentials.UserName, credentials.Password);
if (identity == null)
{
return(BadRequest(Errors.AddErrorToModelState("login_failure", "Invalid username or password.", ModelState)));
}
// Serialize and return the response
var response = new
{
id = identity.Claims.Single(c => c.Type == "id").Value,
auth_token = await _jwtFactory.GenerateEncodedToken(credentials.UserName, identity),
expires_in = (int)_jwtOptions.ValidFor.TotalSeconds
};
var json = JsonConvert.SerializeObject(response, _serializerSettings);
return(new OkObjectResult(json));
}
public async Task <IActionResult> Validate([FromBody] CredentialsDTO account)
{
try
{
var result = await _plexAccountService.ValidatePlexAccountAsync(account.Username, account.Password);
if (result.IsFailed)
{
string msg = $"The account failed to validate, {result}";
Log.Error(msg);
return(BadRequest(result.WithError(msg)));
}
if (result.Value)
{
string msg = $"Account with username: {account.Username} was valid";
Log.Information(msg);
return(Ok(Result.Ok(true).WithSuccess(msg)));
}
else
{
string msg = $"Account with username: {account.Username} was invalid";
Log.Warning(msg);
return(Ok(Result.Fail(msg)));
}
}
catch (Exception e)
{
return(InternalServerError(e));
}
}
private void Button_sign_in_Click(object sender, EventArgs e)
{
CredentialsDTO credentials = new CredentialsDTO()
{
Login = textbox_email.Text,
Password = textbox_password.Text
};
if (_authenticationService.UserExist(textbox_email.Text))
{
if (_authenticationService.CheckCredentials(credentials))
{
MenuForm menu = DependencyInjectorBLL.Resolve <MenuForm>(
new ParameterOverride("user", _userService.GetByEmail(credentials.Login)));
menu.Show();
this.Hide();
}
else
{
MessageBox.Show(
"Wrong password!",
"Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
else
{
MessageBox.Show(
"There is no such user!",
"Error",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
}
}
public async Task <LoginResultDTO> Login(CredentialsDTO credentials)
{
var loginAsJson = JsonSerializer.Serialize(credentials);
var response = await _httpClient.PostAsync("api/Login", new StringContent(loginAsJson, Encoding.UTF8, "application/json"));
var loginResult = JsonSerializer.Deserialize <LoginResultDTO>(await response.Content.ReadAsStringAsync(), new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
});
if (!response.IsSuccessStatusCode || !loginResult.Successful)
{
return(loginResult);
}
await _localStorage.StoreAsync(new GlobeLocalStorageData
{
Token = loginResult.Token,
UserName = credentials.UserName
});
await((ApiAuthenticationStateProvider)_authenticationStateProvider).MarkUserAsAuthenticated(credentials.UserName);
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", loginResult.Token);
return(loginResult);
}
public async Task TestAuthenticate()
{
var tokenDO = CreateAndAddTokenDO();
var activityTemplateDO = new ActivityTemplateDO("test_name", "test_label", "1", "test_description", tokenDO.TerminalID);
activityTemplateDO.Id = FixtureData.GetTestGuidById(1);
activityTemplateDO.Terminal = ObjectFactory.GetInstance <ITerminal>().GetByKey(tokenDO.TerminalID);
activityTemplateDO.Terminal.AuthenticationType = AuthenticationType.Internal;
var activityDO = FixtureData.TestActivity1();
activityDO.ActivityTemplate = activityTemplateDO;
// activityDO.AuthorizationToken = tokenDO;
using (var uow = ObjectFactory.GetInstance <IUnitOfWork>())
{
uow.PlanRepository.Add(new PlanDO()
{
Name = "name",
PlanState = PlanState.Executing,
ChildNodes = { activityDO }
});
//uow.ActivityRepository.Add(activityDO);
uow.ActivityTemplateRepository.Add(activityTemplateDO);
uow.SaveChanges();
}
var credentialsDTO = new CredentialsDTO()
{
Password = "******",
Username = "******",
Domain = "Domain",
Terminal = Mapper.Map <TerminalSummaryDTO>(activityTemplateDO.Terminal)
};
var result = _authenticationController.Authenticate(credentialsDTO);
//Assert
Mock <IRestfulServiceClient> restClientMock = Mock.Get(
ObjectFactory.GetInstance <IRestfulServiceClient>()
);
//verify that the post call is made
restClientMock.Verify(
client => client.PostAsync <CredentialsDTO>(
new Uri(activityTemplateDO.Terminal.Endpoint + "/authentication/token"),
It.Is <CredentialsDTO>(it => it.Username == credentialsDTO.Username &&
it.Password == credentialsDTO.Password &&
it.Domain == credentialsDTO.Domain), It.IsAny <string>(), It.IsAny <Dictionary <string, string> >()
),
Times.Exactly(1)
);
restClientMock.VerifyAll();
}
public ConexionOdooBuilder addUserName(string userName)
{
if (isNull(credentials))
{
credentials = new CredentialsDTO();
}
credentials.userName = userName;
return(this);
}
public ConexionOdooBuilder addDbName(string dbName)
{
if (isNull(credentials))
{
credentials = new CredentialsDTO();
}
credentials.dbName = dbName;
return(this);
}
public ConexionOdooBuilder addUrl(string url)
{
if (isNull(credentials))
{
credentials = new CredentialsDTO();
}
credentials.url = url;
return(this);
}
public ConexionOdooBuilder addCredentials(CredentialsDTO obj)
{
credentials = new CredentialsDTO
{
url = obj.url,
dbName = obj.dbName,
userName = obj.userName,
password = obj.password
};
return(this);
}
public CredentialsDTO GetDocuSignCredentials()
{
var creds = new CredentialsDTO
{
Username = ConfigurationManager.AppSettings["TestUserEmail"],
Password = ConfigurationManager.AppSettings["DocuSignApiPassword"],
IsDemoAccount = true
};
return(creds);
}
public async Task <IActionResult> GetToken(CredentialsDTO credentials)
{
(string jwt, DateTime expiration) = await _authService.CreateJWT(credentials);
if (string.IsNullOrWhiteSpace(jwt))
{
return(BadRequest(new { message = "Username or Password is incorrect" }));
}
return(Ok(new { jwt, expiration }));
}
public async Task <ActionResult> CreateCredential([FromBody] CredentialsDTO credentialsDTO)
{
try
{
return(Ok());
}
catch (Exception e)
{
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public IActionResult Post([FromBody] CredentialsDTO credentials)
{
if (_service.Authenticate(credentials.Login, credentials.Password))
{
return(Ok());
}
else
{
return(StatusCode(StatusCodes.Status401Unauthorized));
}
}
public async Task <IActionResult> Login(CredentialsDTO credentials)
{
var reseller = await _resellerService.Authenticate(credentials);
if (reseller != null)
{
var token = await _authenticationProvider.GenerateToken(Guid.NewGuid());
return(await ResponseAsync(token));
}
return(Unauthorized());
}
public async Task <ApplicationUser> Login(CredentialsDTO credentials)
{
var user = await _userManager.FindByEmailAsync(credentials.Login);
if (user == null)
{
return(null);
}
var loginResult = await _signInManager.CheckPasswordSignInAsync(user, credentials.Password, false);
return(loginResult.Succeeded ? user : null);
}
/// <summary>
/// Authenticates user and returns jwt token.
/// </summary>
/// <param name="credentials"></param>
/// <returns></returns>
public async Task <string> Authenticate(CredentialsDTO credentials)
{
//Validate credentials and generate user identity
ClaimsIdentity identity = null;
try
{
identity = await GetClaimsIdentity(credentials.UserName, credentials.Password);
}// rethrow exception
catch (InvalidOperationException) { throw; }
return(await Helpers.Tokens.GenerateJwt(identity, _jwtFactory, credentials.UserName, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented }));
}
public async Task <bool> CheckAuthenticationAsync(CredentialsDTO credentials)
{
try
{
await GetAsync("configuration", credentials).ConfigureAwait(false);
return(true);
}
catch (AuthorizationTokenExpiredOrInvalidException)
{
return(false);
}
}
public async Task <ActionResult <ResponseDTO <TokenDTO> > > getToken([FromBody] CredentialsDTO credentials)
{
if (credentials.UserName == null || credentials.Password == null)
{
return(new ResponseDTO <TokenDTO>("No credentials were given"));
}
if (!await AuthenticationController.CredentialsValid(credentials))
{
return(new ResponseDTO <TokenDTO>("Credentials invalid"));
}
return(new ResponseDTO <TokenDTO>(await AuthenticationController.GenerateToken(credentials.UserName)));
}
public bool CheckCredentials(CredentialsDTO credentials)
{
User user = _userDal.GetByLogin(credentials.Login);
if (user.HashPassword == HashPassword.Hash(credentials.Password))
{
return(true);
}
else
{
return(false);
}
}
public static AuthorizationTokenDTO Jira_AuthToken()
{
var curCredentialsDTO = new CredentialsDTO()
{
Domain = "https://maginot.atlassian.net",
Username = "******",
Password = "******"
};
return(new AuthorizationTokenDTO()
{
Token = JsonConvert.SerializeObject(curCredentialsDTO)
});
}
public async Task <Response <AuthInfoDTO> > Authenticate(CredentialsDTO dto)
{
var user = await _usersRepository.GetByEmail(dto.Email);
var isPasswordValid = false;
try
{
isPasswordValid = await ValidatePassword(dto.Password, user);
}
catch (Exception e)
{
_logger.LogError(e, e.Message);
return(new SecurityErrorResponse <AuthInfoDTO>(new []
{
new Error
{
Code = ErrorCodes.Security.AuthDataInvalid,
Message = ErrorMessages.Security.AuthDataInvalid
}
}));
}
if (user == null || !isPasswordValid)
{
return(new SecurityErrorResponse <AuthInfoDTO>(new []
{
new Error
{
Code = ErrorCodes.Security.AuthDataInvalid,
Message = ErrorMessages.Security.AuthDataInvalid
}
}));
}
var tokenDTO = await _tokenFactory.CreateToken(user);
var userDTO = _mapper.Map <UserModel, UserDTO>(user);
var result = new AuthInfoDTO
{
User = userDTO,
Token = tokenDTO
};
return(new Response <AuthInfoDTO>
{
Data = result
});
}
public async Task <IActionResult> Login(CredentialsDTO credentialsDto, [FromServices] IAuthenticationService authenticationService)
{
try
{
// Returns JWT if credentials are valid otherwise throws InvalidOperationException
var jwt = await authenticationService.Authenticate(credentialsDto);
return(Ok(jwt));
}
catch (InvalidOperationException e)
{
return(BadRequest(e.Message));
}
}
public async Task <IActionResult> Post([FromBody] CredentialsDTO credentials)
{
var user = await _identityService.Login(credentials);
if (user == null)
{
return(Response());
}
else
{
var responseData = BuildLoginResponse(user);
return(Response(responseData));
}
}
public ActionResult Login([FromBody] CredentialsDTO credentials)
{
User user = _BLL.Login(credentials);;
if (user != null)
{
return(Ok(new
{
token = new JwtSecurityTokenHandler().WriteToken(GenerateToken(user.UserName, user.IntId))
}));
}
return(Unauthorized());
}
public async Task <ResellerDTO> Authenticate(CredentialsDTO credentials)
{
var reseller = _resellerRepository.FindBy(x => x.Email == credentials.Email);
if (reseller != null)
{
var verified = credentials.Password.VerifyHash(reseller.Password);
if (verified)
{
return(_mapper.Map <ResellerDTO>(reseller));
}
}
return(null);
}
