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 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); }