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