public bool UpdateUser(UserDTO User)
{
UserAuthenticationRequest request = new UserAuthenticationRequest();
request.User = User;
return(_iSurveyAnswerRepository.UpdateUser(request));
}
public UserAuthenticationResponse UserLogin(UserAuthenticationRequest request)
{
var response = new UserAuthenticationResponse();
Epi.Web.Enter.Interfaces.DataInterfaces.IDaoFactory entityDaoFactory = new EFwcf.EntityDaoFactory();
Epi.Web.Enter.Interfaces.DataInterface.IUserDao IUserDao = entityDaoFactory.UserDao;
Epi.Web.BLL.User Implementation = new Epi.Web.BLL.User(IUserDao);
UserBO UserBO = Mapper.ToUserBO(request.User);
UserBO result = Implementation.GetUser(UserBO);
if (result != null)
{
//response.Acknowledge = AcknowledgeType.Failure; TBD
//response.Message = "Invalid Pass Code.";
response.User = Mapper.ToUserDTO(result);
response.UserIsValid = true;
}
else
{
response.UserIsValid = false;
}
return(response);
}
public bool UpdateUser(UserDTO User)
{
UserAuthenticationRequest request = new UserAuthenticationRequest();
request.User = User;
return(_securityDataService.UpdateUser(request));
}
async Task Login()
{
IsBusy = true;
APIService.Username = Username;
APIService.Password = Password;
var request = new UserAuthenticationRequest()
{
Username = APIService.Username,
Password = APIService.Password
};
var user = await userService.Authenticate(request);
if (user != null)
{
Application.Current.MainPage = new MainPage();
SignedInUser.User = user;
new LikeHelper();
}
else
{
await Application.Current.MainPage.DisplayAlert("Error", "Enter a Valid Username and Password!", "OK");
}
}
public void CanExecuteResetPasswordStep2()
{
foreach (var testUser in TestAccounts.Accounts)
{
var ctx = UnitTestContext.Get(EnvironmentHelper.GetEnvironment(),
testUser.Username);
var payload = new UserAuthenticationRequest()
{
UserName = testUser.Username,
FullSsn = testUser.FullSsn
};
var step1Result = ApiUtil.PostJson <dynamic>(ctx, "Animation/Membership/Password/Reset0", payload);
Assert.IsNotNull(step1Result);
Assert.AreEqual(HttpStatusCode.OK, step1Result.Item1);
Assert.IsNotNull(step1Result.Item2);
payload.SecretQuestion = step1Result.Item2.Question;
payload.SecretAnswer = testUser.SecretAnswer;
payload.NewPassword = testUser.Password;
var step2Result = ApiUtil.PostJson <dynamic>(ctx, "Animation/Membership/Password/Reset2", payload);
Assert.IsNotNull(step2Result);
Assert.AreEqual(HttpStatusCode.OK, step2Result.Item1);
Assert.IsNotNull(step2Result.Item2);
}
}
public bool UpdateUser(UserAuthenticationRequest pRequest)
{
try
{
//UserAuthenticationResponse result = _iDataService.PassCodeLogin(pRequest);
return(_iDataService.UpdateUser(pRequest));
}
catch (FaultException <CustomFaultException> cfe)
{
throw cfe;
}
catch (FaultException fe)
{
throw fe;
}
catch (CommunicationException ce)
{
throw ce;
}
catch (TimeoutException te)
{
throw te;
}
catch (Exception ex)
{
throw ex;
}
}
async Task SignIn()
{
IsBusy = true;
APIService.Username = Username;
APIService.Password = Password;
var request = new UserAuthenticationRequest()
{
Username = APIService.Username,
Password = APIService.Password
};
var user = await _service.Authenticate(request);
if (user != null)
{
var userRole = user.UserRoles.FirstOrDefault(i => i.Role.Name == "User");
if (userRole != null)
{
Application.Current.MainPage = new MainPage();
SignedInUserHelper.User = user;
new FavouritesHelper();
}
}
else
{
await Application.Current.MainPage.DisplayAlert("Error", "Wrong Username or Password", "OK");
}
}
public UserAuthenticationResponse GetUser(UserAuthenticationRequest request)
{
try
{
var response = new UserAuthenticationResponse();
Epi.Web.Enter.Interfaces.DataInterfaces.IDaoFactory entityDaoFactory = new EFwcf.EntityDaoFactory();
Epi.Web.Enter.Interfaces.DataInterface.IUserDao IUserDao = entityDaoFactory.UserDao;
Epi.Web.BLL.User Implementation = new Epi.Web.BLL.User(IUserDao);
UserBO UserBO = Mapper.ToUserBO(request.User);
// UserBO result = Implementation.GetUserByUserId(UserBO);
UserBO result = Implementation.GetUserByEmail(UserBO);
if (result != null)
{
response.User = Mapper.ToUserDTO(result);
}
return(response);
}
catch (Exception ex)
{
throw ex;
}
}
public UserAuthenticationResponse UpdatePassCode(UserAuthenticationRequest AuthenticationRequest)
{
try
{
UserAuthenticationResponse result = _iDataService.SetPassCode(AuthenticationRequest);
return(result);
}
catch (FaultException <CustomFaultException> cfe)
{
throw cfe;
}
catch (FaultException fe)
{
throw fe;
}
catch (CommunicationException ce)
{
throw ce;
}
catch (TimeoutException te)
{
throw te;
}
catch (Exception ex)
{
throw ex;
}
}
public UserAuthenticationResponse PassCodeLogin(UserAuthenticationRequest request)
{
var response = new UserAuthenticationResponse();
Epi.Web.Interfaces.DataInterfaces.IDaoFactory entityDaoFactory = new EF.EntityDaoFactory();
Epi.Web.Interfaces.DataInterfaces.ISurveyResponseDao ISurveyResponseDao = entityDaoFactory.SurveyResponseDao;
Epi.Web.Interfaces.DataInterfaces.ISurveyInfoDao ISurveyInfoDao = entityDaoFactory.SurveyInfoDao;
Epi.Web.BLL.SurveyResponse Implementation = new Epi.Web.BLL.SurveyResponse(ISurveyResponseDao, ISurveyInfoDao);
UserAuthenticationRequestBO PassCodeBO = Mapper.ToPassCodeBO(request);
bool result = Implementation.ValidateUser(PassCodeBO);
if (result)
{
response.Acknowledge = AcknowledgeType.Failure;
response.Message = "Invalid Pass Code.";
response.UserIsValid = true;
}
else
{
response.UserIsValid = false;
}
return(response);
}
public UserAuthenticationResponse GetUserInfo(UserAuthenticationRequest pRequest)
{
try
{
UserAuthenticationResponse result = _iDataService.GetUser(pRequest);
return(result);
}
catch (FaultException <CustomFaultException> cfe)
{
throw cfe;
}
catch (FaultException fe)
{
throw fe;
}
catch (CommunicationException ce)
{
throw ce;
}
catch (TimeoutException te)
{
throw te;
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <AuthenticationResponse> LoginAsync(UserAuthenticationRequest userReq)
{
var user = await _userManager.FindByEmailAsync(userReq.Email);
if (user == null)
{
return(new AuthenticationResponse
{
ErrorMessages = new[] { "User does not exist." },
Success = false
});
}
var userHasValidPassword = await _userManager.CheckPasswordAsync(user, userReq.Password);
await _userManager.AddClaimAsync(user, new Claim(Claims.Users, "true"));//TODO:DELETE
if (!userHasValidPassword)
{
return(new AuthenticationResponse
{
ErrorMessages = new[] { "Email/Password are incorrect." },
Success = false
});
}
return(await GenerateAuthenticationResultAsync(user));
}
public async Task <AuthenticationResponse> RegisterAsync(UserAuthenticationRequest userReq)
{
var existingUser = await _userManager.FindByEmailAsync(userReq.Email);
if (existingUser != null)
{
return(new AuthenticationResponse
{
ErrorMessages = new[] { "User with this email already exists." },
Success = false
});
}
var newUser = new User
{
Id = Guid.NewGuid().ToString(),
Email = userReq.Email,
UserName = userReq.UserName,
LastName = userReq.LastName
};
var createdUser = await _userManager.CreateAsync(newUser, userReq.Password);
if (!createdUser.Succeeded)
{
return(new AuthenticationResponse
{
ErrorMessages = createdUser.Errors.Select(x => x.Description),
Success = false
});
}
return(await GenerateAuthenticationResultAsync(newUser));
}
// [ApiConventionMethod(typeof(DefaultApiConventions), nameof(DefaultApiConventions.Get))]
public async Task <IActionResult> Authenticate([FromBody] UserAuthenticationRequest user, [FromServices] IFluentEmail email)
{
if (!await _authentication.ValidateUserAsync(user.UserName, user.Password))
{
return(Unauthorized());
}
try
{
var userDefinition = await _authentication.GetUserDefinitionAsync(user.UserName);
var template = @"Dear @Name, You are totally
@Name2. <hr/>
<h1>Big Problems en el sistema </h1>";
//await email
// .To("*****@*****.**")
// .Subject("Prueba de Correo")
// .UsingTemplate(template, new{ Name = "Francisco Areas", Name2="Managua,Nicaragua"} )
// .SendAsync();
return(Ok(new { Token = await _authentication.GetTokenAuthenticateAsync(userDefinition) }));
}
catch (Exception e)
{
Console.WriteLine(e);
throw;
}
}
public static UserAuthenticationRequestBO ToPassCodeBO(UserAuthenticationRequest UserAuthenticationObj)
{
return(new UserAuthenticationRequestBO
{
ResponseId = UserAuthenticationObj.SurveyResponseId,
PassCode = UserAuthenticationObj.PassCode
});
}
public IActionResult Register([FromBody] UserAuthenticationRequest request)
{
if (AccountLogic.Register(request, "User"))
{
return(Ok());
}
return(StatusCode(StatusCodes.Status409Conflict));
}
public HttpResponseMessage Register1(String hsId, [FromBody] UserAuthenticationRequest hsRequest)
{
dynamic eo = new ExpandoObject();
HttpResponseMessage hrm = Request.CreateErrorResponse(HttpStatusCode.Unauthorized, new Exception("Client Handshake is Not Authorized"));
var e = new CCHEncrypt();
if (ValidateConsumer.IsValidConsumer(hsId))
{
hrm = Request.CreateErrorResponse(HttpStatusCode.Unauthorized, new Exception("User was Not Found"));
if (RegDateOfBirth.IsMatch(hsRequest.DateOfBirth))
{
using (var gefae = new GetEnrollmentsForAllEmployers()) {
hsRequest.LastFourSsn = hsRequest.LastFourSsn.Trim().Length > 4
? hsRequest.LastFourSsn.Substring(hsRequest.LastFourSsn.Length - 4, 4)
: hsRequest.LastFourSsn;
gefae.LastName = hsRequest.LastName;
gefae.LastFour = hsRequest.LastFourSsn;
//DateTime birthDate = DateTime.Parse(hsRequest.DateOfBirth);
//gefae.DateOfBirth = string.Format("{0}-{1}-{2}", birthDate.Year, birthDate.Month, birthDate.Day);
gefae.DateOfBirth = hsRequest.DateOfBirth;
gefae.GetFrontEndData();
if (gefae.Tables.Count > 0 &&
gefae.Tables[0].Rows.Count > 0)
{
DataRow dr = gefae.Tables[0].Rows[0];
int cchid = dr.GetData <int>("CCHID");
int employerId = dr.GetData <int>("employerid");
string connString = dr.GetData("connectionstring");
//UserAccess Check dstrickland 7/8/2015
using (var cpaa = new CheckPersonApplicationAccess(cchid, connString)) {
if (!cpaa.HasAccess)
{
return(Request.CreateErrorResponse(HttpStatusCode.Unauthorized,
new Exception(cpaa.ErrorMessage)));
}
}
e.UserKey = Request.EncryptionKey();
e.SecretKey = Properties.Settings.Default.SecretKey;
e.Add("CCHID", cchid.ToString(CultureInfo.InvariantCulture));
e.Add("EmployerID", employerId.ToString(CultureInfo.InvariantCulture));
e.Add("UserID", hsId);
((IDictionary <string, object>)eo)["AuthHash"] = e.ToString();
hrm = Request.CreateResponse(HttpStatusCode.OK, (eo as ExpandoObject));
//LogUserLoginHistory(null, cchid, connString);
}
}
}
}
return(hrm);
}
public bool UpdateUser(UserAuthenticationRequest request)
{
Epi.Web.BLL.User userImplementation = new Epi.Web.BLL.User(_userDao);
UserBO UserBO = request.User.ToUserBO();
OrganizationBO OrgBO = new OrganizationBO();
return(userImplementation.UpdateUser(UserBO, OrgBO));
}
public async Task <IActionResult> Login(UserAuthenticationRequest userAuthenticationRequest)
{
var authenticatedUser = await _eventManagerApi.AuthenticateUser(userAuthenticationRequest);
TempData["userToken"] = authenticatedUser.Token;
TempData["userName"] = authenticatedUser.FirstName;
return(RedirectToAction("Index", "Event"));
}
public async Task <IActionResult> Authenticate(UserAuthenticationRequest request)
{
try
{
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var user = await this.userManager.FindByNameAsync(request.Username);
if (user == null)
{
return(this.Unauthorized(new { message = "Authentication failed" }));
}
var result = await this.signInManager.PasswordSignInAsync(user, request.Password, false, false);
if (!result.Succeeded)
{
return(this.Unauthorized(new { message = "Authentication failed" }));
}
var claims = new List <Claim>
{
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.Sub, user.Id.ToString()),
new Claim(JwtRegisteredClaimNames.UniqueName, user.UserName)
};
var userClaims = new List <Claim>();
var userRoles = await this.userManager.GetRolesAsync(user);
foreach (var role in userRoles)
{
var identityRole = await this.roleManager.FindByNameAsync(role);
userClaims.Add(new Claim("role", identityRole.Name));
userClaims.AddRange(await this.roleManager.GetClaimsAsync(identityRole));
}
userClaims.AddRange(await this.userManager.GetClaimsAsync(user));
claims.AddRange(userClaims);
var token = this.authTokenGeneratorService.GenerateToken(claims);
var response = new UserAuthenticationResponse
{
IsSuccessful = true,
Message = $"Authenticate: Successfully authenticated user: [{ user.Id }].",
Permissions = userClaims.Where(x => x.Type != "role").Select(x => x.Value).ToList(),
Roles = userRoles.ToList(),
Token = token,
UserId = user.Id,
Username = user.UserName
};
return(this.Ok(response));
}
catch (Exception ex)
{
this.loggerManager.LogError(ex.ToString());
return(StatusCode(500, "Authentication failed"));
}
}
public HttpResponseMessage PasswordReset2(UserAuthenticationRequest request)
{
dynamic data = new ExpandoObject();
using (GetEmployerConnString gecs = new GetEmployerConnString(Request.EmployerID())) {
using (GetUserContentPreference gucp = new GetUserContentPreference()) {
gucp.CCHID = Request.CCHID();
gucp.GetData(gecs.ConnString);
data.ContactPhoneNumber = gucp.ContactPhoneNumber;
}
}
string userName = Request.UserName();
MembershipUser mu = Membership.GetUser(userName);
if (mu == null)
{
data.Fail = true;
data.ErrorMessage = "Unexpected Error locating User Membership";
}
else
{
if (string.IsNullOrEmpty(request.SecretAnswer))
{
data.Fail = true;
data.ErrorMessage = "Missing Password Security Secret Answer";
}
else
{
try {
// Reset the password using the secret answer; the new password is a system-generated one
string newPwd = mu.ResetPassword(request.SecretAnswer);
// Use the system-generated password to change to the new user-provided password
if (mu.ChangePassword(newPwd, request.NewPassword))
{
mu.Comment = string.Empty;
Membership.UpdateUser(mu);
data.Success = true;
}
else
{
data.Fail = true;
data.ErrorMessage = "Wrong Password Security Secret Answer";
}
}
catch (Exception exc) {
data.Fail = true;
data.ErrorMessage = exc.Message;
}
}
}
HttpResponseMessage hrm = Request.CreateResponse(HttpStatusCode.OK, (object)data);
return(hrm);
}
public void UpdatePassCode(string ResponseId, string Passcode)
{
// convert DTO to UserAuthenticationRquest
_PassCodeDTO.ResponseId = ResponseId;
_PassCodeDTO.PassCode = Passcode;
UserAuthenticationRequest AuthenticationRequestObj = Mapper.ToUserAuthenticationObj(_PassCodeDTO);
SurveyHelper.UpdatePassCode(AuthenticationRequestObj, _iSurveyAnswerRepository);
}
public async Task <MUser> Authenticate(UserAuthenticationRequest request)
{
try
{
var url = $"{ApiUrl}/User/Authenticate";
return(await url.WithBasicAuth(Username, Password).PostJsonAsync(request).ReceiveJson <MUser>());
}
catch (FlurlHttpException)
{
return(default);
public void UpdatePassCode(string responseId, string passcode)
{
// convert DTO to UserAuthenticationRquest
var passCodeDTO = new PassCodeDTO {
ResponseId = responseId, PassCode = passcode
};
UserAuthenticationRequest authenticationRequest = passCodeDTO.ToUserAuthenticationObj();
SurveyHelper.UpdatePassCode(authenticationRequest, _securityDataService);
}
public IActionResult Login([FromBody] UserAuthenticationRequest request)
{
User user = Auth.Authenticate(request);
if (user == null)
{
return(NotFound());
}
return(StatusCode(StatusCodes.Status202Accepted, new UserAuthenticationResult(user.Id, user.Token, options.Value.TokenExpirationMinutes)));
}
public async Task <IActionResult> Authenticate([FromBody] UserAuthenticationRequest request)
{
var token = await _authService.AuthenticateAsync(request.Email, request.Password);
var response = new AuthSuccessResponse {
Token = token
};
return(token != null?Ok(response) : Unauthorized());
}
public void GetUserAuthenticationResponse()
{
var request = new UserAuthenticationRequest()
{
EmailAddress = "*****@*****.**",
Password = "******"
};
var response = this.FutureStarDAL.UserAuthentication(request);
Assert.IsNotNull(response);
}
public void TestGuestAccess()
{
//for guest will use token binding with that device
var request = new UserAuthenticationRequest()
{
UserName = "******", Token = Guid.NewGuid().ToString()
};
var response = this.FutureStarDAL.UserAuthentication(request);
Assert.IsFalse(string.IsNullOrEmpty(response.Token));
}
public bool UpdateUser(UserAuthenticationRequest request)
{
Epi.Web.Enter.Interfaces.DataInterfaces.IDaoFactory entityDaoFactory = new EF.EntityDaoFactory();
Epi.Web.Enter.Interfaces.DataInterface.IUserDao IUserDao = entityDaoFactory.UserDao;
Epi.Web.BLL.User Implementation = new Epi.Web.BLL.User(IUserDao);
UserBO UserBO = Mapper.ToUserBO(request.User);
OrganizationBO OrgBO = new OrganizationBO();
return(Implementation.UpdateUser(UserBO, OrgBO));
}
public UserAuthenticationResponse SetPassCode(UserAuthenticationRequest request)
{
var response = new UserAuthenticationResponse();
SurveyResponseProvider surveyResponseImplementation = new SurveyResponseProvider(_surveyResponseDao);
Epi.Cloud.Common.BusinessObjects.UserAuthenticationRequestBO PassCodeBO = request.ToPassCodeBO();
surveyResponseImplementation.SavePassCode(PassCodeBO);
return(response);
}
public string Authenticate(UserAuthenticationRequest userAuthenticationRequest)
{
var encryptedPassword = _hashProvider.Hash(userAuthenticationRequest.Password);
userAuthenticationRequest.Username = userAuthenticationRequest.Username.ToLower();
var user = _userStorageApplication.GetAll()
.Where(
u =>
u.Username == userAuthenticationRequest.Username &&
u.Password == encryptedPassword)
.FirstOrDefault();
if (user == null)
{
throw new UnauthorizedAccessException();
}
var accessToken = _securityAccessTokenProvider.CreateAccessToken(user.Id, userAuthenticationRequest);
return accessToken;
}
public string CreateAccessToken(string userId, UserAuthenticationRequest userAuthenticationRequest)
{
var sessionDurationRequest = new SessionDurationRequest()
{
Days = userAuthenticationRequest.Duration.Days,
Hours = userAuthenticationRequest.Duration.Hours,
Minutes = userAuthenticationRequest.Duration.Minutes,
Seconds = userAuthenticationRequest.Duration.Seconds
};
var session = _sessionProvider.GetSession(userId);
if (session == null)
{
session = _sessionProvider.CreateSession(userId, sessionDurationRequest);
}
else
{
session = _sessionProvider.ValidateSession(session);
}
return _encryptionProvider.Encrypt(JsonConvert.SerializeObject(session));
}
public string CreateUser(User user)
{
user.Password = _hashProvider.Hash(user.Password);
user.Username = user.Username.ToLower();
var newUser = _userSecurityStorageProvider.Add(user);
if (!_securityContext.EnableLoginUserOnCreation)
{
return null;
}
var loginUserOnCreationDuration = _securityContext.LoginUserOnCreationDuration;
var userAuthenticationRequest = new UserAuthenticationRequest()
{
Duration = new UserAuthorizationDurationRequest()
{
Days = loginUserOnCreationDuration.Days,
Hours = loginUserOnCreationDuration.Hours,
Minutes = loginUserOnCreationDuration.Minutes,
Seconds = loginUserOnCreationDuration.Seconds
}
};
return _securityAccessTokenProvider.CreateAccessToken(newUser.Id, userAuthenticationRequest);
}
/// <summary> /// User authentication request processing. /// </summary> /// <param name="netRequest"><see cref="UserAuthenticationRequest"/> to verify user data from.</param> /// <param name="settings"><see cref="LoginServiceSettings"/> object.</param> /// <returns><see cref="UserAuthenticationResponse"/> struct.</returns> public abstract UserAuthenticationResponse User_Auth( UserAuthenticationRequest netRequest, LoginServiceSettings settings );
