public ValidateUserResponse Get(ValidateUserRequest request)
{
return(new ValidateUserResponse
{
Data = authenticationService.ValidateUser(request.Data.UserName, request.Data.Password)
});
}
/// <summary>
/// ValidateUser
/// </summary>
/// <param name="request">The request object containing the details to send. Required.</param>
/// <param name="retryConfiguration">The retry configuration that will be used by to send this request. Optional.</param>
/// <param name="cancellationToken">The cancellation token to cancel this operation. Optional.</param>
/// <returns>A response object containing details about the completed operation</returns>
public async Task <ValidateUserResponse> ValidateUser(ValidateUserRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default)
{
logger.Trace("Called validateUser");
Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/v2/incidents/user/validate".Trim('/')));
HttpMethod method = new HttpMethod("Get");
HttpRequestMessage requestMessage = Converter.ToHttpRequestMessage(uri, method, request);
requestMessage.Headers.Add("Accept", "application/json");
GenericRetrier retryingClient = Retrier.GetPreferredRetrier(retryConfiguration, this.retryConfiguration);
HttpResponseMessage responseMessage;
try
{
if (retryingClient != null)
{
responseMessage = await retryingClient.MakeRetryingCall(this.restClient.HttpSend, requestMessage, cancellationToken);
}
else
{
responseMessage = await this.restClient.HttpSend(requestMessage);
}
return(Converter.FromHttpResponseMessage <ValidateUserResponse>(responseMessage));
}
catch (Exception e)
{
logger.Error($"ValidateUser failed with error: {e.Message}");
throw;
}
}
protected override void ProcessRecord()
{
base.ProcessRecord();
ValidateUserRequest request;
try
{
request = new ValidateUserRequest
{
Csi = Csi,
Ocid = Ocid,
OpcRequestId = OpcRequestId,
ProblemType = ProblemType,
Homeregion = Homeregion
};
response = client.ValidateUser(request).GetAwaiter().GetResult();
WriteOutput(response, response.ValidationResponse);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
public async Task ValidateUser(ValidateUserRequest validateUserRequest)
{
var resource = "/v1/account/validate";
var request = new HttpRequestMessage(HttpMethod.Post, resource);
await Execute(request, validateUserRequest);
}
public Response ValidateUser(ValidateUserRequest request)
{
try
{
var ds = _dal.GetUser(request.EmailAddress);
ValidateUserResponseOK retval = new ValidateUserResponseOK();
retval.UserNotExists = true;
if (ds.Tables.Count > 0)
{
var tbl = ds.Tables[0];
if (tbl.Rows.Count == 1)
{
if (request.EmailAddress == (string)tbl.Rows[0][0])
{
retval.UserNotExists = false;
}
}
}
return(retval);
}
catch (Exception ex)
{
return(new ResponseError(ex.Message));
}
}
internal ValidateUserResponse ValidatUser(ValidateUserRequest validateUserRequest)
{
logger.Debug("Recived validate user request");
ValidateUserResponse ValidateUserResponse;
try
{
validateUserRequest.email = Decryptor.Decrypt(validateUserRequest.email).Split('|')[1];
validateUserRequest.username = Decryptor.Decrypt(validateUserRequest.username).Split('|')[1];
int usersWithEmail, UsersWithUserName = 0;
using (var ctx = new PetWhizzEntities())
{
usersWithEmail = ctx.users.Where(a => a.eMail.ToLower().Equals(validateUserRequest.email.ToLower())).Count();
UsersWithUserName = ctx.users.Where(a => a.userName.ToLower().Equals(validateUserRequest.username.ToLower())).Count();
}
if (usersWithEmail > 0 || UsersWithUserName > 0)
{
logger.Error("Email or Username Already Exist userName - " + validateUserRequest.username + " email - " + validateUserRequest.email);
throw new CustomException("Email or Username Already Exist", (int)ErrorCode.EMAILORUSERNAMEALREADYEXIST);
}
ValidateUserResponse = new ValidateUserResponse()
{
messege = "Success"
};
}
catch (CustomException) { throw; }
catch (Exception ex)
{
logger.Error(MethodBase.GetCurrentMethod().Name + ": exception: " + ex.Message + ", " + ex.InnerException);
throw new CustomException("SystemError", ex, (int)ErrorCode.PROCEESINGERROR); throw;
}
return(ValidateUserResponse);
}
public ValidateUserResponse Get(ValidateUserRequest request)
{
return new ValidateUserResponse
{
Data = authenticationService.ValidateUser(request.Data.UserName, request.Data.Password)
};
}
public Response <UserDto> ValidateUser(ValidateUserRequest request)
{
try
{
var connectionString = GetConnectionStringByEmail(request.Email);
_userRepository = new UserRepository(_customerContextFactory.CreateDbContext(connectionString));
var user = _userRepository.FindUserByEmail(request.Email);
if (user == null)
{
throw new ServiceException(ResponseCode.NotFound, "User can not be found with provided Email.");
}
var valid = user.ValidatePassword(request.Password);
if (valid)
{
var dto = _mapper.Map <UserDto>(user);
return(new Response <UserDto>(dto));
}
return(new Response <UserDto>(ResponseCode.ValidationError, "Failed Login"));
}
catch (Exception e)
{
return(HandleException <UserDto>(e));
}
}
/// <summary>
/// Obtains a claim for the given user.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>
/// The response object.
/// </returns>
public async Task <ValidateUserResponse> ValidateUser(ValidateUserRequest request)
{
return(await Orchestrate(async delegate {
var userDataModel = await repository.GetUser(request.EmailAddress, request.Password);
return assembler.NewValidateUserResponse(userDataModel, request.RequestReference);
}, request));
}
public ValidateUserResponse Get(ValidateUserRequest request)
{
var userId = authenticationService.GetUserIdIfValid(request.Data.UserName, request.Data.Password);
return new ValidateUserResponse
{
Data = new ValidUserModel { UserId = userId, Valid = userId.HasValue && userId.Value != Guid.Empty }
};
}
public string ValidateUser(string username, string password)
{
ValidateUserRequest inValue = new ValidateUserRequest();
inValue.username = username;
inValue.password = password;
ValidateUserResponse retVal = ((IPDAOrder)(this)).ValidateUser(inValue);
return(retVal.ValidateUserResult);
}
public ValidateUserResponse Get(ValidateUserRequest request)
{
var userId = authenticationService.GetUserIdIfValid(request.Data.UserName, request.Data.Password);
return(new ValidateUserResponse
{
Data = new ValidUserModel {
UserId = userId, Valid = userId.HasValue && userId.Value != Guid.Empty
}
});
}
public void SetUp()
{
_rootRepoMock = new Mock <IRootRepository>();
_settingRepoMock = new Mock <ISettingRepository>();
_customerContextFactoryMock = new Mock <IDbCustomerDatabaseFactory>();
_mapperMock = new Mock <IMapper>();
_customerDatabaseMock = new Mock <dbCustomerDatabase>();
_userDbSetMock = new Mock <DbSet <User> >();
//Having to due all of this due to multi-tenency set up, I can't inject UserRepo
var data = new List <User>
{
new User(Guid.NewGuid(), "Name", "Email", "Password")
}
.AsQueryable();
_userDbSetMock.As <IQueryable <User> >().Setup(m => m.Provider).Returns(data.Provider);
_userDbSetMock.As <IQueryable <User> >().Setup(m => m.Expression).Returns(data.Expression);
_userDbSetMock.As <IQueryable <User> >().Setup(m => m.ElementType).Returns(data.ElementType);
_userDbSetMock.As <IQueryable <User> >().Setup(m => m.GetEnumerator()).Returns(data.GetEnumerator());
_customerDatabaseMock.Setup(c => c.Users).Returns(_userDbSetMock.Object);
_authService = new AuthService(
_rootRepoMock.Object,
_settingRepoMock.Object,
_customerContextFactoryMock.Object,
_mapperMock.Object);
_request = new ValidateUserRequest("Email", "Password");
var guid = Guid.NewGuid();
var connectionString =
new Encryption(
Key,
Salt,
guid.ToByteArray())
.EncryptString("Connection String");
_connection = new RootConnection(guid, connectionString);
_userDto = new UserDto
{
UserGuid = Guid.NewGuid(),
UserId = 1,
Email = "Email Address",
Name = "Name"
};
}
public PetWhizzResponse ValidateUser(ValidateUserRequest ValidateUserRequest)
{
PetWhizzResponse _oResponse;
try
{
ValidateUserResponse ValidateUserResponse = userServices.ValidatUser(ValidateUserRequest);
_oResponse = Utils.CreateSuccessResponse(ValidateUserResponse);
}
catch (Exception ex)
{
_oResponse = Utils.CreateErrorResponse(ex);
}
return(_oResponse);
}
public void ValidateUserServiceExceptionUserNotFoundTest()
{
_rootRepoMock.Setup(x => x.FindConnectionByEmail(It.IsAny <string>())).Returns(_connection);
_settingRepoMock.Setup(x => x.FindSettingAsString(SettingName.EncryptionSalt)).Returns(Salt);
_settingRepoMock.Setup(x => x.FindSettingAsString(SettingName.EncryptionKey)).Returns(Key);
_customerContextFactoryMock.Setup(x => x.CreateDbContext(It.IsAny <string>())).Returns(_customerDatabaseMock.Object);
_request = new ValidateUserRequest("WrongEmail", "Password");
var response = _authService.ValidateUser(_request);
Assert.IsNotNull(response);
Assert.AreEqual(ResponseCode.NotFound, response.Code);
Assert.IsNotEmpty(response.ErrorMessage);
Assert.IsNull(response.Entity);
}
public async Task <StatusCodeResult> PostValidateUserAsync(string username, ValidateUserRequest request)
{
try
{
await _userService.ValidateUserAsync(username, request.ActivationCode);
}
catch (UserNotFoundException)
{
return(StatusCode(StatusCodes.Status403Forbidden));
}
catch (InvalidUserActivationCodeException)
{
return(StatusCode(StatusCodes.Status403Forbidden));
}
return(StatusCode(StatusCodes.Status204NoContent));
}
public ValidateUserResponse validateUser(ValidateUserRequest request)
{
ValidateUserResponse response = new ValidateUserResponse();
try
{
LogicCommon com = new LogicCommon();
string result = "";
result = com.HttpPost("user/validate", request);
response = JsonConvert.DeserializeObject <ValidateUserResponse>(result);
}
catch (Exception ex) {
response.code = -1;
response.message = "Ocurrio un error inesperado, favor avisar al administrador.";
}
return(response);
}
public void TearDown()
{
orchestrator = null;
assembler = null;
dataAccess = null;
validRegisterViewModel = null;
validRegisterUserRequest = null;
invalidRegisterUserRequest = null;
validRegisterUserResponse = null;
invalidRegisterUserResponse = null;
invalidRegisterViewModel = null;
invalidLoginViewModel = null;
validLoginViewModel = null;
validValidateUserRequest = null;
invalidValidateUserRequest = null;
validValidateUserResponse = null;
invalidValidateUserResponse = null;
}
public ContentResult ValidateUser([FromBody] ValidateUserRequest request)
{
string result = "";
try
{
Validate v = new Validate();
if (v.ValidateToken(request.access_token) == false)
{
return(rtnTokenError());
}
result = webapi.ValidateUser(request.userCode, request.password);
}
catch (Exception ex)
{
return(rtnExError(ex));
}
return(new ContentResult {
Content = result, ContentType = "application/json"
});
}
public async Task <IActionResult> Post([FromBody] ValidateUserRequest request)
{
var response = new ServiceResponse <ValidateUserResponse> {
IsSuccess = false, TokenStatus = TokenStatus.Valid
};
if (request == null)
{
return(BadRequest(ApiMessages.DataNotProvided));
}
else if (!Validation.ValidateEmail(request.EmailId))
{
return(Ok(new ServiceResponse <ValidateUserResponse> {
IsSuccess = false, Message = ApiMessages.InvalidEmail, TokenStatus = TokenStatus.NotRequired
}));
}
response = await _validateUserManager.ValidateUser(request);
return(Ok(response));
}
public ActionResult Login(ValidateUserRequest valUser)
{
ValidateUserResponse response = new ValidateUserResponse();
if (ModelState.IsValid)
{
AdminUserConnection cnn = new AdminUserConnection();
response = cnn.validateUser(valUser);
if (response.code == 0)
{
Session.Add("user", valUser.user);
Session.Add("userName", response.userName);
return(RedirectToAction("Bienvenido", "Home"));
}
}
ViewBag.message = response.message;
// Si llego aquí es porque estaban mal las credenciales
return(View());
}
/// <summary>
/// Checks whether the requested user is valid.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public ValidateUserResponse ValidateUser(ValidateUserRequest request)
{
string uriStr = $"{GetEndPoint(SupportManagementServices.Incidents, this.Region)}/user/validate";
if (!string.IsNullOrEmpty(request.ProblemType))
{
uriStr = $"{uriStr}?{request.ProblemType}";
}
var uri = new Uri(uriStr);
var headers = new HttpRequestHeaderParam()
{
OpcRequestId = request.OpcRequestId
};
headers.FreeHeader.Add("csi", request.Csi);
headers.FreeHeader.Add("ocid", request.Ocid);
if (!string.IsNullOrEmpty(request.Homeregion))
{
headers.FreeHeader.Add("homeregion", request.Homeregion);
}
using (var webResponse = this.RestClient.Get(uri, headers))
using (var stream = webResponse.GetResponseStream())
using (var reader = new StreamReader(stream))
{
var response = reader.ReadToEnd();
return(new ValidateUserResponse()
{
ValidationResponse = this.JsonSerializer.Deserialize <ValidationResponseDetails>(response),
OpcRequestId = webResponse.Headers.Get("opc-request-id"),
ETag = webResponse.Headers.Get("ETag")
});
}
}
private bool InternalValidateUser(string domainUsername, string password)
{
var request = new ValidateUserRequest
{
UserName = domainUsername,
Password = password,
ScopeId = GetCurrentScope()
};
try
{
var response = _client.Send(request);
return(response.Success);
}
catch (WebException ex)
{
throw new ProviderException(ex.Message, ex);
}
catch (WebServiceException ex)
{
throw new ProviderException(ex.ErrorMessage, ex);
}
}
/// <summary>
/// Validate user.
/// </summary>
/// <param name="request">
/// The request.
/// </param>
/// <returns>
/// True if user valid.
/// </returns>
public ValidateUserResponse ValidateUser(ValidateUserRequest request)
{
return new ValidateUserResponse();
}
public static async Task <ValidateUserResponse> ValidateUserApi(ValidateUserRequest request)
{
return(await CustomHttpClient.Post <ValidateUserResponse>(request, "/ValidateUser"));
}
/// <summary>
/// Sends a request to obtain the claims identity information for the given user.
/// </summary>
/// <param name="request">The request object.</param>
/// <returns>
/// The response object.
/// </returns>
public async Task <ValidateUserResponse> ValidateUser(ValidateUserRequest request)
{
return(await Post <ValidateUserResponse>(request));
}
ValidateUserResponse IPDAOrder.ValidateUser(ValidateUserRequest request)
{
return(base.Channel.ValidateUser(request));
}
public void SetUp()
{
validRegisterUserRequest =
new RegisterUserRequest
{
DateOfBirth = DateTime.Today,
EmailAddress = "TEST",
FirstName = "TEST",
LastName = "TEST",
Password = "******",
Username = "******"
};
validDataModel = new UserDataModel
{
Id = Guid.NewGuid(),
CreationTime = DateTime.Now,
DateOfBirth = DateTime.Today,
EmailAddress = "TEST",
FirstName = "TEST",
Hash = new byte[] { },
Iterations = 1,
LastName = "TEST",
Salt = new byte[] { }
};
validRegisterUserResponse =
new RegisterUserResponse
{
RegisterSuccess = true,
RequestReference = validRegisterUserRequest.RequestReference
};
invalidDataModel = new UserDataModel();
invalidRegisterUserRequest = new RegisterUserRequest();
invalidRegisterUserResponse = new RegisterUserResponse {
Errors = { new ResponseErrorWrapper() }
};
exceptionRegisterUserRequest = new RegisterUserRequest {
DateOfBirth = DateTime.MinValue
};
validValidateUserRequest =
new ValidateUserRequest {
EmailAddress = "TEST", Password = "******", Username = "******"
};
invalidValidateUserRequest = new ValidateUserRequest();
exceptionValidateUserRequest = new ValidateUserRequest {
EmailAddress = "EXC", Password = "******", Username = "******"
};
invalidValidateUserResponse = new ValidateUserResponse {
Errors = { new ResponseErrorWrapper() }
};
validValidateUserResponse = new ValidateUserResponse {
LoginSuccess = true
};
assembler = Substitute.For <IUserAssembler>();
repository = Substitute.For <IUserRepository>();
assembler.NewUserDataModel(validRegisterUserRequest).Returns(validDataModel);
assembler.NewUserDataModel(invalidRegisterUserRequest).Returns(invalidDataModel);
assembler.NewRegisterUserResponse(validDataModel, validRegisterUserRequest.RequestReference)
.Returns(validRegisterUserResponse);
assembler.NewUserDataModel(exceptionRegisterUserRequest).Throws(new Exception("TEST"));
assembler.NewRegisterUserResponse(invalidDataModel, invalidRegisterUserRequest.RequestReference)
.Returns(invalidRegisterUserResponse);
assembler.NewValidateUserResponse(validDataModel, validValidateUserRequest.RequestReference)
.Returns(validValidateUserResponse);
assembler.NewValidateUserResponse(invalidDataModel, invalidValidateUserRequest.RequestReference)
.Returns(invalidValidateUserResponse);
repository.RegisterUser(validDataModel).Returns(validDataModel);
repository.RegisterUser(invalidDataModel).Returns(invalidDataModel);
repository.GetUser(validValidateUserRequest.EmailAddress, validValidateUserRequest.Password)
.Returns(validDataModel);
repository.GetUser(invalidValidateUserRequest.EmailAddress, invalidRegisterUserRequest.Password)
.Returns(invalidDataModel);
repository.GetUser(exceptionValidateUserRequest.EmailAddress, exceptionValidateUserRequest.Password)
.Throws(new Exception("TEST"));
errorHelper = Substitute.For <IErrorHelper>();
errorHelper.Create(Arg.Any <Exception>(), Arg.Any <string>(), Arg.Any <Type>(), Arg.Any <string>())
.Returns(new ResponseErrorWrapper());
errorHelper.Create(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <Type>(), Arg.Any <string>())
.Returns(new ResponseErrorWrapper());
orchestrator = new UserOrchestrator(assembler, repository, errorHelper);
}
public async Task <IHttpActionResult> ValidateUser([FromBody] ValidateUserRequest request)
{
var response = await orchestrator.ValidateUser(request);
return(Ok(response));
}
ValidateUserResponse IUserService.Validate(ValidateUserRequest request)
{
return validateUserService.Get(request);
}
public ValidateUserResponse Get(ValidateUserRequest request)
{
throw new CmsException(UsersApiConstants.UsersApiHasNoImplementationMessage);
}
ValidateUserResponse IUserService.Validate(ValidateUserRequest request)
{
return(validateUserService.Get(request));
}
public Response ValidateUser([FromBody] ValidateUserRequest request)
{
return(_service.ValidateUser(request));
}
public ValidateUserResponse Get(ValidateUserRequest request)
{
throw new CmsException(UsersApiConstants.UsersApiHasNoImplementationMessage);
}
public async Task <ServiceResponse <ValidateUserResponse> > ValidateUser(ValidateUserRequest validateUserRequest)
{
_logger.Information("Call ValidateUserManager : ValidateUser");
var response = new ServiceResponse <ValidateUserResponse> {
IsSuccess = true, TokenStatus = TokenStatus.NotRequired
};
using (IDalContext dalContext = new DalContext(_connectionStrings.HackConnection))
{
var dalRequest = new ValidateDalRequest {
EmailId = validateUserRequest.EmailId
};
var dalResponse = await _validateUser.ValidateUser(dalContext.DbConnection, dalRequest);
//Check if success returned from DB
if (!dalResponse.IsSuccess || dalResponse.UserId <= 0)
{
response.Data = new ValidateUserResponse
{
SecurityToken = string.Empty,
};
response.TokenStatus = dalResponse.TokenStatus;
response.IsSuccess = false;
response.Message = dalResponse.ErrorMessage ?? ApiMessages.InternalError;
}
else
{
response.IsSuccess = true;
//Encrypt token
var encryptedToken = Cryptology.EncryptString(string.Format("{0}##{1}##{2}", Utilities.CreateShortGuid(), dalResponse.UserId,
DateTime.UtcNow.AddHours(Constants.ValidTokenDuration).ToString(ServiceConstants.DateFormat)), _logger);
try
{
response.IsSuccess = true;
{
response.Data = new ValidateUserResponse
{
SecurityToken = encryptedToken,
};
response.TokenStatus = dalResponse.TokenStatus;
response.IsSuccess = dalResponse.IsSuccess;
}
}
catch (SqlException ex)
{ //Write Log for exception message
_logger.Error(ex.Message);
response.IsSuccess = false;
response.Message = ServiceConstants.ErrorCodes.ContainsKey(ex.Number)
? ServiceConstants.ErrorCodes[ex.Number]
: ApiMessages.InternalError;
}
catch (Exception ex)
{
_logger.Error("Error : {ex}", ex);
response.IsSuccess = false;
response.Message = ApiMessages.InternalError;
}
}
}
return(response);
}
