Refine search
@Override @Transactional(TransactionUtils.DEFAULT_TRANSACTION_MANAGER) public GenericResponse sendForgotUsernameNotification(String emailAddress) { GenericResponse response = new GenericResponse(); List<Customer> customers = null; if (emailAddress != null) { customers = customerDao.readCustomersByEmail(emailAddress); } if (CollectionUtils.isEmpty(customers)) { response.addErrorCode("notFound"); } else { List<String> activeUsernames = new ArrayList<String>(); for (Customer customer : customers) { if (!customer.isDeactivated()) { activeUsernames.add(customer.getUsername()); } } if (activeUsernames.size() > 0) { HashMap<String, Object> vars = new HashMap<String, Object>(); vars.put("userNames", activeUsernames); sendEmail(emailAddress, getForgotUsernameEmailInfo(), vars); } else { // send inactive username found email. response.addErrorCode("inactiveUser"); } } return response; }
@Override @Transactional(TransactionUtils.DEFAULT_TRANSACTION_MANAGER) public Customer registerCustomer(Customer customer, String password, String passwordConfirm) { customer.setRegistered(true); // When unencodedPassword is set the save() will encode it if (customer.getId() == null) { customer.setId(findNextCustomerId()); } customer.setUnencodedPassword(password); Customer retCustomer = saveCustomer(customer); createRegisteredCustomerRoles(retCustomer); HashMap<String, Object> vars = new HashMap<String, Object>(); vars.put("customer", retCustomer); sendEmail(customer.getEmailAddress(), getRegistrationEmailInfo(), vars); notifyPostRegisterListeners(retCustomer); return retCustomer; }
cloned.setAnonymous(anonymous); cloned.setChallengeAnswer(challengeAnswer); cloned.setChallengeQuestion(challengeQuestion); cloned.setCookied(cookied); for (CustomerAddress entry : customerAddresses) { CustomerAddress clonedEntry = entry.createOrRetrieveCopyInstance(context).getClone(); clonedEntry.setCustomer(cloned); cloned.getCustomerAddresses().add(clonedEntry); CustomerAttribute clonedEntry = entry.getValue().createOrRetrieveCopyInstance(context).getClone(); clonedEntry.setCustomer(cloned); cloned.getCustomerAttributes().put(entry.getKey(), clonedEntry); cloned.setLoggedIn(loggedIn); cloned.setUsername(username); cloned.setUnencodedPassword(unencodedPassword); cloned.setTaxExemptionCode(taxExemptionCode); cloned.setUnencodedChallengeAnswer(unencodedChallengeAnswer); cloned.setRegistered(registered); cloned.setReceiveEmail(receiveEmail); cloned.setPasswordChangeRequired(passwordChangeRequired); cloned.setPassword(password); cloned.setLastName(lastName); cloned.setFirstName(firstName); cloned.setEmailAddress(emailAddress); cloned.setDeactivated(deactivated); for (CustomerPayment entry : customerPayments) { CustomerPayment clonedEntry = entry.createOrRetrieveCopyInstance(context).getClone(); clonedEntry.setCustomer(cloned);
@Override public Authentication loginCustomer(Customer customer) { return loginCustomer(customer.getUsername(), customer.getUnencodedPassword()); }
protected void addCustomerData(Map<String, Object> attrMap) { Customer customer = CustomerState.getCustomer(); String firstName = ""; String lastName = ""; boolean anonymous = false; if (customer != null) { if (!StringUtils.isEmpty(customer.getFirstName())) { firstName = customer.getFirstName(); } if (!StringUtils.isEmpty(customer.getLastName())) { lastName = customer.getLastName(); } if (customer.isAnonymous()) { anonymous = true; } } attrMap.put("firstName", firstName); attrMap.put("lastName", lastName); attrMap.put("anonymous", anonymous); }
@Deprecated @Override public Object getSalt(Customer customer, String unencodedPassword) { Object salt = null; if (saltSource != null && customer != null) { salt = saltSource.getSalt(new CustomerUserDetails(customer.getId(), customer.getUsername(), unencodedPassword, new ArrayList<GrantedAuthority>())); } return salt; }
@Test(groups = { "readOrdersForCustomer" }, dependsOnGroups = { "readCustomer", "createOrder" }) @Transactional public void readOrdersForCustomer() { userName = "customer1"; Customer user = customerService.readCustomerByUsername(userName); List<Order> orders = orderDao.readOrdersForCustomer(user.getId()); assert orders.size() > 0; }
@Override @Transactional(TransactionUtils.DEFAULT_TRANSACTION_MANAGER) public GenericResponse resetPasswordUsingToken(String username, String token, String password, String confirmPassword) { GenericResponse response = new GenericResponse(); Customer customer = null; if (username != null) { customer = customerDao.readCustomerByUsername(username); } checkCustomer(customer, response); checkPassword(password, confirmPassword, response); CustomerForgotPasswordSecurityToken fpst = checkPasswordResetToken(token, customer, response); if (!response.getHasErrors()) { if (!customer.getId().equals(fpst.getCustomerId())) { if (LOG.isWarnEnabled()) { LOG.warn("Password reset attempt tried with mismatched customer and token " + customer.getId() + ", " + StringUtil.sanitize(token)); } response.addErrorCode("invalidToken"); } } if (!response.getHasErrors()) { customer.setUnencodedPassword(password); customer.setPasswordChangeRequired(false); saveCustomer(customer); invalidateAllTokensForCustomer(customer); } return response; }
@Test(groups = { "changeCustomerPassword" }, dependsOnGroups = { "readCustomer" }) @Transactional @Commit public void changeCustomerPasswords() { for (String userName : userNames) { Customer customer = customerService.readCustomerByUsername(userName); customer.setPassword(customer.getPassword() + "-Changed"); customerService.saveCustomer(customer); } }
@Override @Transactional(TransactionUtils.DEFAULT_TRANSACTION_MANAGER) public GenericResponse sendForgotPasswordNotification(String username, String resetPasswordUrl) { GenericResponse response = new GenericResponse(); fpst.setCustomerId(customer.getId()); fpst.setToken(encodePass(token, saltString)); fpst.setCreateDate(SystemTime.asDate()); sendEmail(customer.getEmailAddress(), getForgotPasswordEmailInfo(), vars);
@Test(groups = "createCustomerFromController", dataProvider = "setupCustomerControllerData", dataProviderClass = RegisterCustomerDataProvider.class, enabled=false) @Transactional @Rollback(false) public void createCustomerFromController(RegisterCustomerForm registerCustomer) { BindingResult errors = new BeanPropertyBindingResult(registerCustomer, "registerCustomer"); MockHttpServletRequest request = new MockHttpServletRequest(); MockHttpServletResponse response = new MockHttpServletResponse(); registerCustomerController.registerCustomer(registerCustomer, errors, request, response); assert(errors.getErrorCount() == 0); Customer customerFromDb = customerService.readCustomerByUsername(registerCustomer.getCustomer().getUsername()); assert(customerFromDb != null); }
@Transactional @RequestMapping(value = "/register", method = RequestMethod.POST) @ApiOperation( .filter(c -> !c.isRegistered()) .orElseThrow(() -> new ResourceNotFoundException("User already registered")); customer.setUsername(username); customer.setEmailAddress(email);
public String register(RegisterCustomerForm registerCustomerForm, HttpServletRequest request, HttpServletResponse response, Model model) { Connection<?> connection = ProviderSignInUtils.getConnection(new ServletWebRequest(request)); if (connection != null) { UserProfile userProfile = connection.fetchUserProfile(); Customer customer = registerCustomerForm.getCustomer(); customer.setFirstName(userProfile.getFirstName()); customer.setLastName(userProfile.getLastName()); customer.setEmailAddress(userProfile.getEmail()); if (isUseEmailForLogin()){ customer.setUsername(userProfile.getEmail()); } else { customer.setUsername(userProfile.getUsername()); } } return super.register(registerCustomerForm, request, response, model); }
if (customer.isAnonymous()) { GatewayCustomerDTO<PaymentResponseDTO> gatewayCustomer = responseDTO.getCustomer(); if (StringUtils.isEmpty(customer.getFirstName()) && gatewayCustomer != null) { customer.setFirstName(gatewayCustomer.getFirstName()); if (StringUtils.isEmpty(customer.getLastName()) && gatewayCustomer != null) { customer.setLastName(gatewayCustomer.getLastName()); if (StringUtils.isEmpty(customer.getEmailAddress()) && gatewayCustomer != null) { customer.setEmailAddress(gatewayCustomer.getEmail());
@Test(groups = "createCustomers", dependsOnGroups="createCustomerIdGeneration", dataProvider = "setupCustomers", dataProviderClass = CustomerDataProvider.class) @Rollback(false) public void createCustomer(Customer customerInfo) { Customer customer = customerService.createCustomerFromId(null); customer.setPassword(customerInfo.getPassword()); customer.setUsername(customerInfo.getUsername()); Long customerId = customer.getId(); assert customerId != null; customer = customerService.saveCustomer(customer); assert customer.getId() == customerId; userIds.add(customer.getId()); userNames.add(customer.getUsername()); }
@Override public CustomerDto createDto(final Customer customer, final boolean embed, final boolean link) { final CustomerDto customerDto = CustomerDto.builder() .firstName(customer.getFirstName()) .lastName(customer.getLastName()) .username(customer.getUsername()) .email(customer.getEmailAddress()) .locale(Optional.ofNullable(customer.getCustomerLocale()).map(Locale::getLocaleCode).orElse(null)) .addresses( customer.getCustomerAddresses().stream() .collect(toMap( CustomerAddress::getAddressName, customerAddress -> addressConverter.createDto(customerAddress.getAddress(), embed, link) )) ) .build(); customerDto.add(ControllerLinkBuilder.linkTo(methodOn(CustomerController.class).readOneCustomer(null, customer.getId().toString(), null, null)).withSelfRel()); if (link) { customerDto.add(linkTo(methodOn(CustomerController.class).createAuthorizationCode(null, customer.getId().toString())).withRel("authorization")); } return customerDto; }
@Override public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException, DataAccessException { Customer customer = customerService.readCustomerByUsername(username, false); if (customer == null) { throw new UsernameNotFoundException("The customer was not found"); } boolean isActive = !customer.isDeactivated(); if (Status.class.isAssignableFrom(customer.getClass())) { isActive = isActive && ((Status) customer).isActive(); } List<GrantedAuthority> grantedAuthorities = createGrantedAuthorities(roleService.findCustomerRolesByCustomerId(customer.getId())); return new CustomerUserDetails(customer.getId(), username, customer.getPassword(), isActive, true, !customer.isPasswordChangeRequired(), true, grantedAuthorities); }
customer.setEmailAddress("test@test.com"); customer.setFirstName("John"); customer.setLastName("Tester"); customer.setReceiveEmail(true); customer.setRegistered(true);
@DataProvider(name = "setupCustomerControllerData") public static Object[][] createCustomer() { Customer customer = new CustomerImpl(); customer.setEmailAddress("testCase@test.com"); customer.setFirstName("TestFirstName"); customer.setLastName("TestLastName"); customer.setUsername("TestCase"); ChallengeQuestion question = new ChallengeQuestionImpl(); question.setId(1L); customer.setChallengeQuestion(question); customer.setChallengeAnswer("Challenge CandidateItemOfferAnswer"); RegisterCustomerForm registerCustomer = new RegisterCustomerForm(); registerCustomer.setCustomer(customer); registerCustomer.setPassword("TestPassword"); registerCustomer.setPasswordConfirm("TestPassword"); return new Object[][] { new Object[] { registerCustomer } }; } }
Customer findCustomerByid(int id){ for (Customer customer : customers) { if (customer.getId() == id) { return customer; } } return null; }