/** * This method only exists because so many other tests depend on it, but should be removed once tests are more isolated * @param customerAddress */ @Deprecated @Test(groups = "createCustomerAddress", dataProvider = "setupCustomerAddress", dataProviderClass = CustomerAddressDataProvider.class, dependsOnGroups = {"readCustomer", "createCountry", "createState"}) @Transactional @Rollback(false) public void createCustomerAddress(CustomerAddress customerAddress) { userName = "customer1"; Customer customer = customerService.readCustomerByUsername(userName); assert customerAddress.getId() == null; customerAddress.setCustomer(customer); State state = stateService.findStateByAbbreviation("KY"); customerAddress.getAddress().setState(state); Country country = countryService.findCountryByAbbreviation("US"); customerAddress.getAddress().setCountry(country); customerAddress.getAddress().setIsoCountrySubdivision("US-KY"); ISOCountry isoCountry = isoService.findISOCountryByAlpha2Code("US"); customerAddress.getAddress().setIsoCountryAlpha2(isoCountry); customerAddress = customerAddressService.saveCustomerAddress(customerAddress); assert customer.equals(customerAddress.getCustomer()); userId = customerAddress.getCustomer().getId(); }
public String addCustomerAddress(HttpServletRequest request, Model model, CustomerAddressForm form, BindingResult result, RedirectAttributes redirectAttributes) throws ServiceException { addressService.populateAddressISOCountrySub(form.getAddress()); customerAddressValidator.validate(form, result); if (result.hasErrors()) { return getCustomerAddressesView(); } removeUnusedPhones(form); Address address = addressService.saveAddress(form.getAddress()); CustomerAddress customerAddress = customerAddressService.create(); customerAddress.setAddress(address); customerAddress.setAddressName(form.getAddressName()); customerAddress.setCustomer(CustomerState.getCustomer()); customerAddress = customerAddressService.saveCustomerAddress(customerAddress); if (form.getAddress().isDefault()) { customerAddressService.makeCustomerAddressDefault(customerAddress.getId(), customerAddress.getCustomer().getId()); } form.setCustomerAddressId(customerAddress.getId()); if (!isAjaxRequest(request)) { List<CustomerAddress> addresses = customerAddressService.readActiveCustomerAddressesByCustomerId(CustomerState.getCustomer().getId()); model.addAttribute("addresses", addresses); } redirectAttributes.addFlashAttribute("successMessage", getAddressAddedMessage()); return getCustomerAddressesRedirect(); }
@Override public <G extends CustomerAddress> CreateResponse<G> createOrRetrieveCopyInstance(MultiTenantCopyContext context) throws CloneNotSupportedException { CreateResponse<G> createResponse = context.createOrRetrieveCopyInstance(this); if (createResponse.isAlreadyPopulated()) { return createResponse; } CustomerAddress cloned = createResponse.getClone(); cloned.setAddressName(addressName); // dont clone cloned.setCustomer(customer); cloned.setArchived(getArchived()); cloned.setAddress(address.createOrRetrieveCopyInstance(context).getClone()); return createResponse; } }
public void makeCustomerAddressDefault(Long customerAddressId, Long customerId) { List<CustomerAddress> customerAddresses = readActiveCustomerAddressesByCustomerId(customerId); for (CustomerAddress customerAddress : customerAddresses) { customerAddress.getAddress().setDefault(customerAddress.getId().equals(customerAddressId)); em.merge(customerAddress); } }
@Override @Transactional(TransactionUtils.DEFAULT_TRANSACTION_MANAGER) public CustomerAddress saveCustomerAddress(CustomerAddress customerAddress) { // if parameter address is set as default, unset all other default addresses List<CustomerAddress> activeCustomerAddresses = readActiveCustomerAddressesByCustomerId(customerAddress.getCustomer().getId()); if (activeCustomerAddresses != null && activeCustomerAddresses.isEmpty()) { customerAddress.getAddress().setDefault(true); } else { if (customerAddress.getAddress().isDefault()) { for (CustomerAddress activeCustomerAddress : activeCustomerAddresses) { if (!activeCustomerAddress.getId().equals(customerAddress.getId()) && activeCustomerAddress.getAddress().isDefault()) { activeCustomerAddress.getAddress().setDefault(false); customerAddressDao.save(activeCustomerAddress); } } } } return customerAddressDao.save(customerAddress); }
/** * Processes the requested add address from the multiship process. * This method will create a CustomerAddress based on the requested Address * and associate it with the current Customer in session. * * @param request * @param response * @param model * @param addressForm * @return the return path to the multiship page * @throws ServiceException */ public String saveMultishipAddAddress(HttpServletRequest request, HttpServletResponse response, Model model, ShippingInfoForm addressForm, BindingResult result) throws ServiceException { addressService.populateAddressISOCountrySub(addressForm.getAddress()); multishipAddAddressFormValidator.validate(addressForm, result); if (result.hasErrors()) { return showMultishipAddAddress(request, response, model); } removeUnusedPhones(addressForm); CustomerAddress customerAddress = customerAddressService.create(); customerAddress.setAddressName(addressForm.getAddressName()); customerAddress.setAddress(addressForm.getAddress()); customerAddress.setCustomer(CustomerState.getCustomer()); customerAddressService.saveCustomerAddress(customerAddress); //append current time to redirect to fix a problem with ajax caching in IE return getMultishipAddAddressSuccessView() + "?_=" + System.currentTimeMillis(); }
@Override public void determineIfSavedAddressIsSelected(Model model, ShippingInfoForm shippingInfoForm, PaymentInfoForm paymentInfoForm) { Customer customer = CustomerState.getCustomer(); boolean isSavedShippingAddress = false; boolean isSavedBillingAddress = false; for (CustomerAddress customerAddress : customer.getCustomerAddresses()) { if (addressesContentsAreEqual(shippingInfoForm.getAddress(), customerAddress.getAddress())) { isSavedShippingAddress = true; break; } } for (CustomerAddress customerAddress : customer.getCustomerAddresses()) { if (addressesContentsAreEqual(paymentInfoForm.getAddress(), customerAddress.getAddress())) { isSavedBillingAddress = true; break; } } model.addAttribute("isSavedShippingAddress", isSavedShippingAddress); model.addAttribute("isSavedBillingAddress", isSavedBillingAddress); }
public String viewCustomerAddress(HttpServletRequest request, Model model, Long customerAddressId) { CustomerAddress customerAddress = customerAddressService.readCustomerAddressById(customerAddressId); if (customerAddress == null) { throw new IllegalArgumentException("Customer Address not found with the specified customerAddressId"); } validateCustomerOwnedData(customerAddress); CustomerAddressForm form = new CustomerAddressForm(); form.setAddress(customerAddress.getAddress()); form.setAddressName(customerAddress.getAddressName()); form.setCustomerAddressId(customerAddress.getId()); model.addAttribute("customerAddressForm", form); return getCustomerAddressesView(); }
@DataProvider(name = "setupCustomerAddress") public static Object[][] createCustomerAddress() { CustomerAddress ca1 = new CustomerAddressImpl(); Address address1 = new AddressImpl(); address1.setAddressLine1("1234 Merit Drive"); address1.setCity("Bozeman"); address1.setPostalCode("75251"); ca1.setAddress(address1); ca1.setAddressName("address4"); CustomerAddress ca2 = new CustomerAddressImpl(); Address address2 = new AddressImpl(); address2.setAddressLine1("12 Testing Drive"); address2.setCity("Portland"); address2.setPostalCode("75251"); ca2.setAddress(address2); ca2.setAddressName("address5"); return new Object[][] { new Object[] { ca1 }, new Object[] { ca2 } }; } }
if (ca.getAddress().getId() == null) { ca.getAddress().setId(queryFactory.insert(address) .populate(ca.getAddress()) .executeWithKey(address.id)); .set(customerAddress.addressId, ca.getAddress().getId()) .set(customerAddress.addressTypeCode, ca.getAddressTypeCode()) .set(customerAddress.fromDate, ca.getFromDate()) .set(customerAddress.toDate, ca.getToDate()) .addBatch();
@Override public ShippingInfoForm prePopulateShippingInfoForm(ShippingInfoForm shippingInfoForm, Order cart) { FulfillmentGroup firstShippableFulfillmentGroup = fulfillmentGroupService.getFirstShippableFulfillmentGroup(cart); if (firstShippableFulfillmentGroup != null) { //if the cart has already has fulfillment information if (firstShippableFulfillmentGroup.getAddress() != null) { shippingInfoForm.setAddress(firstShippableFulfillmentGroup.getAddress()); } else { //check for a default address for the customer CustomerAddress defaultAddress = customerAddressService.findDefaultCustomerAddress(CustomerState.getCustomer().getId()); if (defaultAddress != null) { shippingInfoForm.setAddress(defaultAddress.getAddress()); shippingInfoForm.setAddressName(defaultAddress.getAddressName()); } } FulfillmentOption fulfillmentOption = firstShippableFulfillmentGroup.getFulfillmentOption(); if (fulfillmentOption != null) { shippingInfoForm.setFulfillmentOption(fulfillmentOption); shippingInfoForm.setFulfillmentOptionId(fulfillmentOption.getId()); } } return shippingInfoForm; }
cloned.setCookied(cookied); for (CustomerAddress entry : customerAddresses) { CustomerAddress clonedEntry = entry.createOrRetrieveCopyInstance(context).getClone(); clonedEntry.setCustomer(cloned); cloned.getCustomerAddresses().add(clonedEntry);
Customer cust = new Customer(); CustomerAddress custAddr = new CustomerAddress(); cust.setCustomerAddress( custAddr ); custAddr.setCustomer( cust );
/** * Creates a country, state, and customer with the supplied customerAddress * @param customerAddress * @return customer created */ public CustomerAddress createCustomerWithAddress(CustomerAddress customerAddress) { createCountry(); createState(); Customer customer = createCustomer(); customer.setUsername(String.valueOf(customer.getId())); customerAddress.setCustomer(customer); return saveCustomerAddress(customerAddress); }
protected void validateCustomerOwnedData(CustomerAddress customerAddress) { if (validateCustomerOwnedData) { Customer activeCustomer = CustomerState.getCustomer(); if (activeCustomer != null && !(activeCustomer.equals(customerAddress.getCustomer()))) { throw new SecurityException("The active customer does not own the object that they are trying to view, edit, or remove."); } if (activeCustomer == null && customerAddress.getCustomer() != null) { throw new SecurityException("The active customer does not own the object that they are trying to view, edit, or remove."); } } }
address.setArchived('Y');
.map(entry -> { CustomerAddress customerAddress = customerAddressService.create(); customerAddress.setAddressName(entry.getKey()); customerAddress.setAddress(addressConverter.createEntity(entry.getValue())); customerAddress.setCustomer(customer); return customerAddress; })
/** * Saves a customerAddress with state KY and country US. Requires that createCountry() and createState() have been called * @param customerAddress */ public CustomerAddress saveCustomerAddress(CustomerAddress customerAddress) { State state = stateService.findStateByAbbreviation("KY"); customerAddress.getAddress().setState(state); Country country = countryService.findCountryByAbbreviation("US"); customerAddress.getAddress().setCountry(country); customerAddress.getAddress().setIsoCountrySubdivision("US-KY"); ISOCountry isoCountry = isoService.findISOCountryByAlpha2Code("US"); customerAddress.getAddress().setIsoCountryAlpha2(isoCountry); return customerAddressService.saveCustomerAddress(customerAddress); }
@Override public void afterCommit() { ApplicationContextHolder.getApplicationContext().publishEvent(new CustomerPersistedEvent(((CustomerAddress) entity).getCustomer())); } });
@Test(groups = "testCustomerAddress") @Transactional public void createNewDefaultAddress() { Customer customer = createCustomerWithAddresses(); CustomerAddress ca = new CustomerAddressImpl(); Address address = new AddressImpl(); address.setAddressLine1("123 Main"); address.setCity("Dallas"); address.setPostalCode("75201"); address.setDefault(true); ca.setAddress(address); ca.setCustomer(customer); ca.setAddressName("address3"); CustomerAddress savedAddress = saveCustomerAddress(ca); List<CustomerAddress> customerAddressList = customerAddressService.readActiveCustomerAddressesByCustomerId(customer.getId()); for (CustomerAddress customerAddress : customerAddressList) { if (customerAddress.getId().equals(savedAddress.getId())) { assert customerAddress.getAddress().isDefault(); } else { assert !customerAddress.getAddress().isDefault(); } } }