001    /**
002     * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.shopping.service.impl;
016    
017    import com.liferay.portal.kernel.exception.PortalException;
018    import com.liferay.portal.kernel.exception.SystemException;
019    import com.liferay.portal.kernel.util.GetterUtil;
020    import com.liferay.portal.kernel.util.Validator;
021    import com.liferay.portal.kernel.workflow.WorkflowConstants;
022    import com.liferay.portal.model.User;
023    import com.liferay.portal.service.ServiceContext;
024    import com.liferay.portal.util.PortletKeys;
025    import com.liferay.portal.util.PropsValues;
026    import com.liferay.portal.util.SubscriptionSender;
027    import com.liferay.portlet.shopping.BillingCityException;
028    import com.liferay.portlet.shopping.BillingCountryException;
029    import com.liferay.portlet.shopping.BillingEmailAddressException;
030    import com.liferay.portlet.shopping.BillingFirstNameException;
031    import com.liferay.portlet.shopping.BillingLastNameException;
032    import com.liferay.portlet.shopping.BillingPhoneException;
033    import com.liferay.portlet.shopping.BillingStateException;
034    import com.liferay.portlet.shopping.BillingStreetException;
035    import com.liferay.portlet.shopping.BillingZipException;
036    import com.liferay.portlet.shopping.CCExpirationException;
037    import com.liferay.portlet.shopping.CCNameException;
038    import com.liferay.portlet.shopping.CCNumberException;
039    import com.liferay.portlet.shopping.CCTypeException;
040    import com.liferay.portlet.shopping.CartMinOrderException;
041    import com.liferay.portlet.shopping.NoSuchOrderException;
042    import com.liferay.portlet.shopping.ShippingCityException;
043    import com.liferay.portlet.shopping.ShippingCountryException;
044    import com.liferay.portlet.shopping.ShippingEmailAddressException;
045    import com.liferay.portlet.shopping.ShippingFirstNameException;
046    import com.liferay.portlet.shopping.ShippingLastNameException;
047    import com.liferay.portlet.shopping.ShippingPhoneException;
048    import com.liferay.portlet.shopping.ShippingStateException;
049    import com.liferay.portlet.shopping.ShippingStreetException;
050    import com.liferay.portlet.shopping.ShippingZipException;
051    import com.liferay.portlet.shopping.model.ShoppingCart;
052    import com.liferay.portlet.shopping.model.ShoppingCartItem;
053    import com.liferay.portlet.shopping.model.ShoppingItem;
054    import com.liferay.portlet.shopping.model.ShoppingItemField;
055    import com.liferay.portlet.shopping.model.ShoppingOrder;
056    import com.liferay.portlet.shopping.model.ShoppingOrderConstants;
057    import com.liferay.portlet.shopping.model.ShoppingOrderItem;
058    import com.liferay.portlet.shopping.model.impl.ShoppingCartItemImpl;
059    import com.liferay.portlet.shopping.service.base.ShoppingOrderLocalServiceBaseImpl;
060    import com.liferay.portlet.shopping.util.ShoppingPreferences;
061    import com.liferay.portlet.shopping.util.ShoppingUtil;
062    import com.liferay.portlet.shopping.util.comparator.OrderDateComparator;
063    import com.liferay.util.CreditCard;
064    import com.liferay.util.PwdGenerator;
065    
066    import java.util.Currency;
067    import java.util.Date;
068    import java.util.Iterator;
069    import java.util.List;
070    import java.util.Map;
071    
072    /**
073     * @author Brian Wing Shun Chan
074     */
075    public class ShoppingOrderLocalServiceImpl
076            extends ShoppingOrderLocalServiceBaseImpl {
077    
078            @Override
079            public ShoppingOrder addLatestOrder(long userId, long groupId)
080                    throws PortalException, SystemException {
081    
082                    // Order
083    
084                    User user = userPersistence.findByPrimaryKey(userId);
085                    Date now = new Date();
086    
087                    String number = getNumber();
088    
089                    ShoppingOrder order = null;
090    
091                    long orderId = counterLocalService.increment();
092    
093                    List<ShoppingOrder> pastOrders =
094                            shoppingOrderPersistence.findByG_U_PPPS(
095                                    groupId, userId, ShoppingOrderConstants.STATUS_CHECKOUT, 0, 1);
096    
097                    if (pastOrders.size() > 0) {
098                            ShoppingOrder pastOrder = pastOrders.get(0);
099    
100                            order = shoppingOrderPersistence.create(orderId);
101    
102                            order.setBillingCompany(pastOrder.getBillingCompany());
103                            order.setBillingStreet(pastOrder.getBillingStreet());
104                            order.setBillingCity(pastOrder.getBillingCity());
105                            order.setBillingState(pastOrder.getBillingState());
106                            order.setBillingZip(pastOrder.getBillingZip());
107                            order.setBillingCountry(pastOrder.getBillingCountry());
108                            order.setBillingPhone(pastOrder.getBillingPhone());
109                            order.setShipToBilling(pastOrder.isShipToBilling());
110                            order.setShippingCompany(pastOrder.getShippingCompany());
111                            order.setShippingStreet(pastOrder.getShippingStreet());
112                            order.setShippingCity(pastOrder.getShippingCity());
113                            order.setShippingState(pastOrder.getShippingState());
114                            order.setShippingZip(pastOrder.getShippingZip());
115                            order.setShippingCountry(pastOrder.getShippingCountry());
116                            order.setShippingPhone(pastOrder.getShippingPhone());
117                    }
118                    else {
119                            order = shoppingOrderPersistence.create(orderId);
120                    }
121    
122                    order.setGroupId(groupId);
123                    order.setCompanyId(user.getCompanyId());
124                    order.setUserId(user.getUserId());
125                    order.setUserName(user.getFullName());
126                    order.setCreateDate(now);
127                    order.setModifiedDate(now);
128                    order.setNumber(number);
129                    order.setBillingFirstName(user.getFirstName());
130                    order.setBillingLastName(user.getLastName());
131                    order.setBillingEmailAddress(user.getEmailAddress());
132                    order.setShippingFirstName(user.getFirstName());
133                    order.setShippingLastName(user.getLastName());
134                    order.setShippingEmailAddress(user.getEmailAddress());
135                    order.setCcName(user.getFullName());
136                    order.setPpPaymentStatus(ShoppingOrderConstants.STATUS_LATEST);
137                    order.setSendOrderEmail(true);
138                    order.setSendShippingEmail(true);
139    
140                    shoppingOrderPersistence.update(order, false);
141    
142                    // Message boards
143    
144                    if (PropsValues.SHOPPING_ORDER_COMMENTS_ENABLED) {
145                            mbMessageLocalService.addDiscussionMessage(
146                                    userId, order.getUserName(), groupId,
147                                    ShoppingOrder.class.getName(), orderId,
148                                    WorkflowConstants.ACTION_PUBLISH);
149                    }
150    
151                    return order;
152            }
153    
154            @Override
155            public void completeOrder(
156                            String number, String ppTxnId, String ppPaymentStatus,
157                            double ppPaymentGross, String ppReceiverEmail, String ppPayerEmail,
158                            boolean updateInventory, ServiceContext serviceContext)
159                    throws PortalException, SystemException {
160    
161                    // Order
162    
163                    ShoppingOrder order = shoppingOrderPersistence.findByNumber(number);
164    
165                    order.setModifiedDate(new Date());
166                    order.setPpTxnId(ppTxnId);
167                    order.setPpPaymentStatus(ppPaymentStatus);
168                    order.setPpPaymentGross(ppPaymentGross);
169                    order.setPpReceiverEmail(ppReceiverEmail);
170                    order.setPpPayerEmail(ppPayerEmail);
171    
172                    shoppingOrderPersistence.update(order, false);
173    
174                    // Inventory
175    
176                    if (updateInventory &&
177                            ppPaymentStatus.equals(ShoppingOrderConstants.STATUS_COMPLETED)) {
178    
179                            List<ShoppingOrderItem> orderItems =
180                                    shoppingOrderItemLocalService.getOrderItems(order.getOrderId());
181    
182                            for (ShoppingOrderItem orderItem : orderItems) {
183                                    ShoppingItem item = shoppingItemLocalService.getItem(
184                                            ShoppingUtil.getItemId(orderItem.getItemId()));
185    
186                                    if (!item.isFields()) {
187                                            int quantity =
188                                                    item.getStockQuantity() - orderItem.getQuantity();
189    
190                                            item.setStockQuantity(quantity);
191                                    }
192                                    else {
193                                            List<ShoppingItemField> itemFields =
194                                                    shoppingItemFieldLocalService.getItemFields(
195                                                            item.getItemId());
196    
197                                            ShoppingItemField[] itemFieldsArray = itemFields.toArray(
198                                                    new ShoppingItemField[itemFields.size()]);
199    
200                                            String[] fieldsArray = ShoppingCartItemImpl.getFieldsArray(
201                                                    ShoppingUtil.getItemFields(orderItem.getItemId()));
202    
203                                            int rowPos = ShoppingUtil.getFieldsQuantitiesPos(
204                                                    item, itemFieldsArray, fieldsArray);
205    
206                                            String[] fieldsQuantities = item.getFieldsQuantitiesArray();
207    
208                                            try {
209                                                    int quantity =
210                                                            GetterUtil.getInteger(fieldsQuantities[rowPos]) -
211                                                            orderItem.getQuantity();
212    
213                                                    fieldsQuantities[rowPos] = String.valueOf(quantity);
214    
215                                                    item.setFieldsQuantitiesArray(fieldsQuantities);
216                                            }
217                                            catch (Exception e) {
218                                            }
219                                    }
220    
221                                    shoppingItemPersistence.update(item, false);
222                            }
223                    }
224    
225                    // Email
226    
227                    sendEmail(order, "confirmation", serviceContext);
228            }
229    
230            @Override
231            public void deleteOrder(long orderId)
232                    throws PortalException, SystemException {
233    
234                    ShoppingOrder order = shoppingOrderPersistence.findByPrimaryKey(
235                            orderId);
236    
237                    deleteOrder(order);
238            }
239    
240            @Override
241            public void deleteOrder(ShoppingOrder order)
242                    throws PortalException, SystemException {
243    
244                    // Order
245    
246                    shoppingOrderPersistence.remove(order);
247    
248                    // Subscriptions
249    
250                    subscriptionLocalService.deleteSubscriptions(
251                            order.getCompanyId(), ShoppingOrder.class.getName(),
252                            order.getOrderId());
253    
254                    // Items
255    
256                    shoppingOrderItemPersistence.removeByOrderId(order.getOrderId());
257    
258                    // Message boards
259    
260                    mbMessageLocalService.deleteDiscussionMessages(
261                            ShoppingOrder.class.getName(), order.getOrderId());
262            }
263    
264            @Override
265            public void deleteOrders(long groupId)
266                    throws PortalException, SystemException {
267    
268                    List<ShoppingOrder> orders = shoppingOrderPersistence.findByGroupId(
269                            groupId);
270    
271                    for (ShoppingOrder order : orders) {
272                            deleteOrder(order);
273                    }
274            }
275    
276            @Override
277            public ShoppingOrder getLatestOrder(long userId, long groupId)
278                    throws PortalException, SystemException {
279    
280                    List<ShoppingOrder> orders = shoppingOrderPersistence.findByG_U_PPPS(
281                            groupId, userId, ShoppingOrderConstants.STATUS_LATEST, 0, 1);
282    
283                    ShoppingOrder order = null;
284    
285                    if (orders.size() == 1) {
286                            order = orders.get(0);
287                    }
288                    else {
289                            order = shoppingOrderLocalService.addLatestOrder(userId, groupId);
290                    }
291    
292                    return order;
293            }
294    
295            @Override
296            public ShoppingOrder getOrder(long orderId)
297                    throws PortalException, SystemException {
298    
299                    return shoppingOrderPersistence.findByPrimaryKey(orderId);
300            }
301    
302            @Override
303            public ShoppingOrder getOrder(String number)
304                    throws PortalException, SystemException {
305    
306                    return shoppingOrderPersistence.findByNumber(number);
307            }
308    
309            @Override
310            public ShoppingOrder getPayPalTxnIdOrder(String ppTxnId)
311                    throws PortalException, SystemException {
312    
313                    return shoppingOrderPersistence.findByPPTxnId(ppTxnId);
314            }
315    
316            @Override
317            public ShoppingOrder saveLatestOrder(ShoppingCart cart)
318                    throws PortalException, SystemException {
319    
320                    Map<ShoppingCartItem, Integer> items = cart.getItems();
321                    Date now = new Date();
322    
323                    ShoppingPreferences shoppingPrefs = ShoppingPreferences.getInstance(
324                            cart.getCompanyId(), cart.getGroupId());
325    
326                    if (!ShoppingUtil.meetsMinOrder(shoppingPrefs, items)) {
327                            throw new CartMinOrderException();
328                    }
329    
330                    ShoppingOrder order = getLatestOrder(
331                            cart.getUserId(), cart.getGroupId());
332    
333                    order.setCreateDate(now);
334                    order.setModifiedDate(now);
335                    order.setPpPaymentStatus(ShoppingOrderConstants.STATUS_CHECKOUT);
336    
337                    shoppingOrderPersistence.update(order, false);
338    
339                    boolean requiresShipping = false;
340    
341                    Iterator<Map.Entry<ShoppingCartItem, Integer>> itr =
342                            items.entrySet().iterator();
343    
344                    while (itr.hasNext()) {
345                            Map.Entry<ShoppingCartItem, Integer> entry = itr.next();
346    
347                            ShoppingCartItem cartItem = entry.getKey();
348                            Integer count = entry.getValue();
349    
350                            ShoppingItem item = cartItem.getItem();
351    
352                            if (item.isRequiresShipping()) {
353                                    requiresShipping = true;
354                            }
355    
356                            long orderItemId = counterLocalService.increment();
357    
358                            ShoppingOrderItem orderItem = shoppingOrderItemPersistence.create(
359                                    orderItemId);
360    
361                            orderItem.setOrderId(order.getOrderId());
362                            orderItem.setItemId(cartItem.getCartItemId());
363                            orderItem.setSku(item.getSku());
364                            orderItem.setName(item.getName());
365                            orderItem.setDescription(item.getDescription());
366                            orderItem.setProperties(item.getProperties());
367                            orderItem.setPrice(
368                                    ShoppingUtil.calculateActualPrice(item, count.intValue()) /
369                                            count.intValue());
370                            orderItem.setQuantity(count.intValue());
371    
372                            shoppingOrderItemPersistence.update(orderItem, false);
373                    }
374    
375                    order.setModifiedDate(new Date());
376                    order.setTax(ShoppingUtil.calculateTax(items, order.getBillingState()));
377                    order.setShipping(
378                            ShoppingUtil.calculateAlternativeShipping(
379                                    items, cart.getAltShipping()));
380                    order.setAltShipping(
381                            shoppingPrefs.getAlternativeShippingName(cart.getAltShipping()));
382                    order.setRequiresShipping(requiresShipping);
383                    order.setInsure(cart.isInsure());
384                    order.setInsurance(ShoppingUtil.calculateInsurance(items));
385                    order.setCouponCodes(cart.getCouponCodes());
386                    order.setCouponDiscount(
387                            ShoppingUtil.calculateCouponDiscount(
388                                    items, order.getBillingState(), cart.getCoupon()));
389                    order.setSendOrderEmail(true);
390                    order.setSendShippingEmail(true);
391    
392                    shoppingOrderPersistence.update(order, false);
393    
394                    return order;
395            }
396    
397            @Override
398            public List<ShoppingOrder> search(
399                            long groupId, long companyId, long userId, String number,
400                            String billingFirstName, String billingLastName,
401                            String billingEmailAddress, String shippingFirstName,
402                            String shippingLastName, String shippingEmailAddress,
403                            String ppPaymentStatus, boolean andOperator, int start, int end)
404                    throws SystemException {
405    
406                    OrderDateComparator obc = new OrderDateComparator(false);
407    
408                    return shoppingOrderFinder.findByG_C_U_N_PPPS(
409                            groupId, companyId, userId, number, billingFirstName,
410                            billingLastName, billingEmailAddress, shippingFirstName,
411                            shippingLastName, shippingEmailAddress, ppPaymentStatus,
412                            andOperator, start, end, obc);
413            }
414    
415            @Override
416            public int searchCount(
417                            long groupId, long companyId, long userId, String number,
418                            String billingFirstName, String billingLastName,
419                            String billingEmailAddress, String shippingFirstName,
420                            String shippingLastName, String shippingEmailAddress,
421                            String ppPaymentStatus, boolean andOperator)
422                    throws SystemException {
423    
424                    return shoppingOrderFinder.countByG_C_U_N_PPPS(
425                            groupId, companyId, userId, number, billingFirstName,
426                            billingLastName, billingEmailAddress, shippingFirstName,
427                            shippingLastName, shippingEmailAddress, ppPaymentStatus,
428                            andOperator);
429            }
430    
431            @Override
432            public void sendEmail(
433                            long orderId, String emailType, ServiceContext serviceContext)
434                    throws PortalException, SystemException {
435    
436                    ShoppingOrder order = shoppingOrderPersistence.findByPrimaryKey(
437                            orderId);
438    
439                    sendEmail(order, emailType, serviceContext);
440            }
441    
442            @Override
443            public void sendEmail(
444                            ShoppingOrder order, String emailType,
445                            ServiceContext serviceContext)
446                    throws PortalException, SystemException {
447    
448                    ShoppingPreferences shoppingPrefs = ShoppingPreferences.getInstance(
449                            order.getCompanyId(), order.getGroupId());
450    
451                    if (emailType.equals("confirmation") &&
452                            shoppingPrefs.getEmailOrderConfirmationEnabled()) {
453                    }
454                    else if (emailType.equals("shipping") &&
455                                     shoppingPrefs.getEmailOrderShippingEnabled()) {
456                    }
457                    else {
458                            return;
459                    }
460    
461                    User user = userPersistence.findByPrimaryKey(order.getUserId());
462    
463                    Currency currency = Currency.getInstance(shoppingPrefs.getCurrencyId());
464    
465                    String billingAddress =
466                            order.getBillingFirstName() + " " + order.getBillingLastName() +
467                                    "<br>" +
468                            order.getBillingEmailAddress() + "<br>" +
469                            order.getBillingStreet() + "<br>" +
470                            order.getBillingCity() + "<br>" +
471                            order.getBillingState() + "<br>" +
472                            order.getBillingZip() + "<br>" +
473                            order.getBillingCountry() + "<br>" +
474                            order.getBillingPhone() + "<br>";
475    
476                    String shippingAddress =
477                            order.getShippingFirstName() + " " + order.getShippingLastName() +
478                                    "<br>" +
479                            order.getShippingEmailAddress() + "<br>" +
480                            order.getShippingStreet() + "<br>" +
481                            order.getShippingCity() + "<br>" +
482                            order.getShippingState() + "<br>" +
483                            order.getShippingZip() + "<br>" +
484                            order.getShippingCountry() + "<br>" +
485                            order.getShippingPhone() + "<br>";
486    
487                    double total = ShoppingUtil.calculateTotal(order);
488    
489                    String fromName = shoppingPrefs.getEmailFromName(order.getCompanyId());
490                    String fromAddress = shoppingPrefs.getEmailFromAddress(
491                            order.getCompanyId());
492    
493                    String toName = user.getFullName();
494                    String toAddress = user.getEmailAddress();
495    
496                    String subject = null;
497                    String body = null;
498    
499                    if (emailType.equals("confirmation")) {
500                            subject = shoppingPrefs.getEmailOrderConfirmationSubject();
501                            body = shoppingPrefs.getEmailOrderConfirmationBody();
502                    }
503                    else if (emailType.equals("shipping")) {
504                            subject = shoppingPrefs.getEmailOrderShippingSubject();
505                            body = shoppingPrefs.getEmailOrderShippingBody();
506                    }
507    
508                    SubscriptionSender subscriptionSender = new SubscriptionSender();
509    
510                    subscriptionSender.setBody(body);
511                    subscriptionSender.setCompanyId(order.getCompanyId());
512                    subscriptionSender.setContextAttributes(
513                            "[$ORDER_BILLING_ADDRESS$]", billingAddress, "[$ORDER_CURRENCY$]",
514                            currency.getSymbol(), "[$ORDER_NUMBER$]", order.getNumber(),
515                            "[$ORDER_SHIPPING_ADDRESS$]", shippingAddress, "[$ORDER_TOTAL$]",
516                            total);
517                    subscriptionSender.setFrom(fromAddress, fromName);
518                    subscriptionSender.setHtmlFormat(true);
519                    subscriptionSender.setMailId("shopping_order", order.getOrderId());
520                    subscriptionSender.setPortletId(PortletKeys.SHOPPING);
521                    subscriptionSender.setScopeGroupId(order.getGroupId());
522                    subscriptionSender.setServiceContext(serviceContext);
523                    subscriptionSender.setSubject(subject);
524                    subscriptionSender.setUserId(order.getUserId());
525    
526                    subscriptionSender.addRuntimeSubscribers(toAddress, toName);
527    
528                    subscriptionSender.flushNotificationsAsync();
529    
530                    if (emailType.equals("confirmation") && order.isSendOrderEmail()) {
531                            order.setSendOrderEmail(false);
532    
533                            shoppingOrderPersistence.update(order, false);
534                    }
535                    else if (emailType.equals("shipping") && order.isSendShippingEmail()) {
536                            order.setSendShippingEmail(false);
537    
538                            shoppingOrderPersistence.update(order, false);
539                    }
540            }
541    
542            @Override
543            public ShoppingOrder updateLatestOrder(
544                            long userId, long groupId, String billingFirstName,
545                            String billingLastName, String billingEmailAddress,
546                            String billingCompany, String billingStreet, String billingCity,
547                            String billingState, String billingZip, String billingCountry,
548                            String billingPhone, boolean shipToBilling,
549                            String shippingFirstName, String shippingLastName,
550                            String shippingEmailAddress, String shippingCompany,
551                            String shippingStreet, String shippingCity, String shippingState,
552                            String shippingZip, String shippingCountry, String shippingPhone,
553                            String ccName, String ccType, String ccNumber, int ccExpMonth,
554                            int ccExpYear, String ccVerNumber, String comments)
555                    throws PortalException, SystemException {
556    
557                    ShoppingOrder order = getLatestOrder(userId, groupId);
558    
559                    return updateOrder(
560                            order.getOrderId(), billingFirstName, billingLastName,
561                            billingEmailAddress, billingCompany, billingStreet, billingCity,
562                            billingState, billingZip, billingCountry, billingPhone,
563                            shipToBilling, shippingFirstName, shippingLastName,
564                            shippingEmailAddress, shippingCompany, shippingStreet, shippingCity,
565                            shippingState, shippingZip, shippingCountry, shippingPhone, ccName,
566                            ccType, ccNumber, ccExpMonth, ccExpYear, ccVerNumber, comments);
567            }
568    
569            @Override
570            public ShoppingOrder updateOrder(
571                            long orderId, String ppTxnId, String ppPaymentStatus,
572                            double ppPaymentGross, String ppReceiverEmail, String ppPayerEmail)
573                    throws PortalException, SystemException {
574    
575                    ShoppingOrder order = shoppingOrderPersistence.findByPrimaryKey(
576                            orderId);
577    
578                    order.setModifiedDate(new Date());
579                    order.setPpTxnId(ppTxnId);
580                    order.setPpPaymentStatus(ppPaymentStatus);
581                    order.setPpPaymentGross(ppPaymentGross);
582                    order.setPpReceiverEmail(ppReceiverEmail);
583                    order.setPpPayerEmail(ppPayerEmail);
584    
585                    shoppingOrderPersistence.update(order, false);
586    
587                    return order;
588            }
589    
590            @Override
591            public ShoppingOrder updateOrder(
592                            long orderId, String billingFirstName, String billingLastName,
593                            String billingEmailAddress, String billingCompany,
594                            String billingStreet, String billingCity, String billingState,
595                            String billingZip, String billingCountry, String billingPhone,
596                            boolean shipToBilling, String shippingFirstName,
597                            String shippingLastName, String shippingEmailAddress,
598                            String shippingCompany, String shippingStreet, String shippingCity,
599                            String shippingState, String shippingZip, String shippingCountry,
600                            String shippingPhone, String ccName, String ccType, String ccNumber,
601                            int ccExpMonth, int ccExpYear, String ccVerNumber, String comments)
602                    throws PortalException, SystemException {
603    
604                    ShoppingOrder order = shoppingOrderPersistence.findByPrimaryKey(
605                            orderId);
606    
607                    ShoppingPreferences shoppingPrefs = ShoppingPreferences.getInstance(
608                            order.getCompanyId(), order.getGroupId());
609    
610                    validate(
611                            shoppingPrefs, billingFirstName, billingLastName,
612                            billingEmailAddress, billingStreet, billingCity, billingState,
613                            billingZip, billingCountry, billingPhone, shipToBilling,
614                            shippingFirstName, shippingLastName, shippingEmailAddress,
615                            shippingStreet, shippingCity, shippingState, shippingZip,
616                            shippingCountry, shippingPhone, ccName, ccType, ccNumber,
617                            ccExpMonth, ccExpYear, ccVerNumber);
618    
619                    order.setModifiedDate(new Date());
620                    order.setBillingFirstName(billingFirstName);
621                    order.setBillingLastName(billingLastName);
622                    order.setBillingEmailAddress(billingEmailAddress);
623                    order.setBillingCompany(billingCompany);
624                    order.setBillingStreet(billingStreet);
625                    order.setBillingCity(billingCity);
626                    order.setBillingState(billingState);
627                    order.setBillingZip(billingZip);
628                    order.setBillingCountry(billingCountry);
629                    order.setBillingPhone(billingPhone);
630                    order.setShipToBilling(shipToBilling);
631    
632                    if (shipToBilling) {
633                            order.setShippingFirstName(billingFirstName);
634                            order.setShippingLastName(billingLastName);
635                            order.setShippingEmailAddress(billingEmailAddress);
636                            order.setShippingCompany(billingCompany);
637                            order.setShippingStreet(billingStreet);
638                            order.setShippingCity(billingCity);
639                            order.setShippingState(billingState);
640                            order.setShippingZip(billingZip);
641                            order.setShippingCountry(billingCountry);
642                            order.setShippingPhone(billingPhone);
643                    }
644                    else {
645                            order.setShippingFirstName(shippingFirstName);
646                            order.setShippingLastName(shippingLastName);
647                            order.setShippingEmailAddress(shippingEmailAddress);
648                            order.setShippingCompany(shippingCompany);
649                            order.setShippingStreet(shippingStreet);
650                            order.setShippingCity(shippingCity);
651                            order.setShippingState(shippingState);
652                            order.setShippingZip(shippingZip);
653                            order.setShippingCountry(shippingCountry);
654                            order.setShippingPhone(shippingPhone);
655                    }
656    
657                    order.setCcName(ccName);
658                    order.setCcType(ccType);
659                    order.setCcNumber(ccNumber);
660                    order.setCcExpMonth(ccExpMonth);
661                    order.setCcExpYear(ccExpYear);
662                    order.setCcVerNumber(ccVerNumber);
663                    order.setComments(comments);
664    
665                    shoppingOrderPersistence.update(order, false);
666    
667                    return order;
668            }
669    
670            protected String getNumber() throws SystemException {
671                    String number = PwdGenerator.getPassword(
672                            PwdGenerator.KEY1 + PwdGenerator.KEY2, 12);
673    
674                    try {
675                            shoppingOrderPersistence.findByNumber(number);
676    
677                            return getNumber();
678                    }
679                    catch (NoSuchOrderException nsoe) {
680                            return number;
681                    }
682            }
683    
684            protected void validate(
685                            ShoppingPreferences shoppingPrefs, String billingFirstName,
686                            String billingLastName, String billingEmailAddress,
687                            String billingStreet, String billingCity, String billingState,
688                            String billingZip, String billingCountry, String billingPhone,
689                            boolean shipToBilling, String shippingFirstName,
690                            String shippingLastName, String shippingEmailAddress,
691                            String shippingStreet, String shippingCity, String shippingState,
692                            String shippingZip, String shippingCountry, String shippingPhone,
693                            String ccName, String ccType, String ccNumber, int ccExpMonth,
694                            int ccExpYear, String ccVerNumber)
695                    throws PortalException {
696    
697                    if (Validator.isNull(billingFirstName)) {
698                            throw new BillingFirstNameException();
699                    }
700                    else if (Validator.isNull(billingLastName)) {
701                            throw new BillingLastNameException();
702                    }
703                    else if (!Validator.isEmailAddress(billingEmailAddress)) {
704                            throw new BillingEmailAddressException();
705                    }
706                    else if (Validator.isNull(billingStreet)) {
707                            throw new BillingStreetException();
708                    }
709                    else if (Validator.isNull(billingCity)) {
710                            throw new BillingCityException();
711                    }
712                    else if (Validator.isNull(billingState)) {
713                            throw new BillingStateException();
714                    }
715                    else if (Validator.isNull(billingZip)) {
716                            throw new BillingZipException();
717                    }
718                    else if (Validator.isNull(billingCountry)) {
719                            throw new BillingCountryException();
720                    }
721                    else if (Validator.isNull(billingPhone)) {
722                            throw new BillingPhoneException();
723                    }
724    
725                    if (!shipToBilling) {
726                            if (Validator.isNull(shippingFirstName)) {
727                                    throw new ShippingFirstNameException();
728                            }
729                            else if (Validator.isNull(shippingLastName)) {
730                                    throw new ShippingLastNameException();
731                            }
732                            else if (!Validator.isEmailAddress(shippingEmailAddress)) {
733                                    throw new ShippingEmailAddressException();
734                            }
735                            else if (Validator.isNull(shippingStreet)) {
736                                    throw new ShippingStreetException();
737                            }
738                            else if (Validator.isNull(shippingCity)) {
739                                    throw new ShippingCityException();
740                            }
741                            else if (Validator.isNull(shippingState)) {
742                                    throw new ShippingStateException();
743                            }
744                            else if (Validator.isNull(shippingZip)) {
745                                    throw new ShippingZipException();
746                            }
747                            else if (Validator.isNull(shippingCountry)) {
748                                    throw new ShippingCountryException();
749                            }
750                            else if (Validator.isNull(shippingPhone)) {
751                                    throw new ShippingPhoneException();
752                            }
753                    }
754    
755                    if (!shoppingPrefs.usePayPal() &&
756                            (shoppingPrefs.getCcTypes().length > 0)) {
757    
758                            if (Validator.isNull(ccName)) {
759                                    throw new CCNameException();
760                            }
761                            else if (Validator.isNull(ccType)) {
762                                    throw new CCTypeException();
763                            }
764                            else if (!CreditCard.isValidNumber(ccNumber, ccType)) {
765                                    throw new CCNumberException();
766                            }
767                            else if (!CreditCard.isValidExpirationDate(ccExpMonth, ccExpYear)) {
768                                    throw new CCExpirationException();
769                            }
770                    }
771            }
772    
773    }