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