return result;

    }

    public static Map<String, Object> getPreviousNextProducts(DispatchContext dctx, Map<String, ? extends Object> context) {

        String categoryId = (String) context.get("categoryId");

        String productId = (String) context.get("productId");

        boolean activeOnly = (context.get("activeOnly") != null ? ((Boolean) context.get("activeOnly")).booleanValue() : true);

        Integer index = (Integer) context.get("index");

        Timestamp introductionDateLimit = (Timestamp) context.get("introductionDateLimit");

        Timestamp releaseDateLimit = (Timestamp) context.get("releaseDateLimit");

        Locale locale = (Locale) context.get("locale");

       

        if (index == null && productId == null) {

            return ServiceUtil.returnFailure(UtilProperties.getMessage(resourceError, "categoryservices.problems_getting_next_products", locale));

        }

        List<String> orderByFields = UtilGenerics.checkList(context.get("orderByFields"));

        if (orderByFields == null) orderByFields = FastList.newInstance();

        String entityName = getCategoryFindEntityName(delegator, orderByFields, introductionDateLimit, releaseDateLimit);

        GenericValue productCategory;

        List<GenericValue> productCategoryMembers;

        try {

        } catch (GenericEntityException e) {

            Debug.logInfo(e, "Error finding previous/next product info: " + e.toString(), module);

            return ServiceUtil.returnFailure(UtilProperties.getMessage(resourceError, "categoryservices.error_find_next_products", UtilMisc.toMap("errMessage", e.getMessage()), locale));

        }

        if (activeOnly) {

        return entityName;

    }

    public static Map<String, Object> getProductCategoryAndLimitedMembers(DispatchContext dctx, Map<String, ? extends Object> context) {

        String productCategoryId = (String) context.get("productCategoryId");

        boolean limitView = ((Boolean) context.get("limitView")).booleanValue();

        int defaultViewSize = ((Integer) context.get("defaultViewSize")).intValue();

        Timestamp introductionDateLimit = (Timestamp) context.get("introductionDateLimit");

        Timestamp releaseDateLimit = (Timestamp) context.get("releaseDateLimit");

        List<String> orderByFields = UtilGenerics.checkList(context.get("orderByFields"));

        if (orderByFields == null) orderByFields = FastList.newInstance();

        String entityName = getCategoryFindEntityName(delegator, orderByFields, introductionDateLimit, releaseDateLimit);

        String prodCatalogId = (String) context.get("prodCatalogId");

        boolean useCacheForMembers = (context.get("useCacheForMembers") == null || ((Boolean) context.get("useCacheForMembers")).booleanValue());

        boolean activeOnly = (context.get("activeOnly") == null || ((Boolean) context.get("activeOnly")).booleanValue());

        // checkViewAllow defaults to false, must be set to true and pass the prodCatalogId to enable

        boolean checkViewAllow = (prodCatalogId != null && context.get("checkViewAllow") != null &&

                ((Boolean) context.get("checkViewAllow")).booleanValue());

        String viewProductCategoryId = null;

        if (checkViewAllow) {

            viewProductCategoryId = CatalogWorker.getCatalogViewAllowCategoryId(delegator, prodCatalogId);

        }

        Timestamp nowTimestamp = UtilDateTime.nowTimestamp();

        int viewIndex = 1;

        try {

            viewIndex = Integer.valueOf((String) context.get("viewIndexString")).intValue();

        } catch (Exception e) {

            viewIndex = 1;

        }

        int viewSize = defaultViewSize;

        try {

            viewSize = Integer.valueOf((String) context.get("viewSizeString")).intValue();

        } catch (Exception e) {

            viewSize = defaultViewSize;

        }

        GenericValue productCategory = null;

        try {

        } catch (GenericEntityException e) {

            Debug.logWarning(e.getMessage(), module);

            productCategory = null;

        }

        int listSize = 0;

        int lowIndex = 0;

        int highIndex = 0;

        if (limitView) {

            // get the indexes for the partial list

            lowIndex = (((viewIndex - 1) * viewSize) + 1);

            highIndex = viewIndex * viewSize;

        } else {

            lowIndex = 0;

            highIndex = 0;

        }

        List<GenericValue> productCategoryMembers = null;

        if (productCategory != null) {

            try {

                if (useCacheForMembers) {

                    if (activeOnly) {

                        productCategoryMembers = EntityUtil.filterByDate(productCategoryMembers, true);

                    }

                    List<EntityCondition> filterConditions = FastList.newInstance();

                    if (introductionDateLimit != null) {

                        EntityCondition condition = EntityCondition.makeCondition(EntityCondition.makeCondition("introductionDate", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition("introductionDate", EntityOperator.LESS_THAN_EQUAL_TO, introductionDateLimit));

                        filterConditions.add(condition);

                    }

                    if (releaseDateLimit != null) {

                        EntityCondition condition = EntityCondition.makeCondition(EntityCondition.makeCondition("releaseDate", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition("releaseDate", EntityOperator.LESS_THAN_EQUAL_TO, releaseDateLimit));

                        filterConditions.add(condition);

                    }

                    if (!filterConditions.isEmpty()) {

                        productCategoryMembers = EntityUtil.filterByCondition(productCategoryMembers, EntityCondition.makeCondition(filterConditions, EntityOperator.AND));

                    }

                    // filter out the view allow before getting the sublist

                    if (UtilValidate.isNotEmpty(viewProductCategoryId)) {

                        productCategoryMembers = CategoryWorker.filterProductsInCategory(delegator, productCategoryMembers, viewProductCategoryId);

                        listSize = productCategoryMembers.size();

                    }

                    // set the index and size

                    listSize = productCategoryMembers.size();

                    if (highIndex > listSize) {

                        highIndex = listSize;

                    }

                    // get only between low and high indexes

                    if (limitView) {

                        if (UtilValidate.isNotEmpty(productCategoryMembers)) {

                            productCategoryMembers = productCategoryMembers.subList(lowIndex-1, highIndex);

                        }

                    } else {

                        lowIndex = 1;

                        highIndex = listSize;

                    }

                } else {

                    List<EntityCondition> mainCondList = FastList.newInstance();

                    mainCondList.add(EntityCondition.makeCondition("productCategoryId", EntityOperator.EQUALS, productCategory.getString("productCategoryId")));

                    if (activeOnly) {

                        mainCondList.add(EntityCondition.makeCondition("fromDate", EntityOperator.LESS_THAN_EQUAL_TO, nowTimestamp));

                        mainCondList.add(EntityCondition.makeCondition(EntityCondition.makeCondition("thruDate", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition("thruDate", EntityOperator.GREATER_THAN, nowTimestamp)));

                    }

                    if (introductionDateLimit != null) {

                        mainCondList.add(EntityCondition.makeCondition(EntityCondition.makeCondition("introductionDate", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition("introductionDate", EntityOperator.LESS_THAN_EQUAL_TO, introductionDateLimit)));

                    }

                    if (releaseDateLimit != null) {

                        mainCondList.add(EntityCondition.makeCondition(EntityCondition.makeCondition("releaseDate", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition("releaseDate", EntityOperator.LESS_THAN_EQUAL_TO, releaseDateLimit)));

                    }

                    EntityCondition mainCond = EntityCondition.makeCondition(mainCondList, EntityOperator.AND);

                    // set distinct on

                    EntityFindOptions findOpts = new EntityFindOptions(true, EntityFindOptions.TYPE_SCROLL_INSENSITIVE, EntityFindOptions.CONCUR_READ_ONLY, false);

                    findOpts.setMaxRows(highIndex);

                    // using list iterator

                    // get the partial list for this page

                    if (limitView) {

                        if (viewProductCategoryId != null) {

                            // do manual checking to filter view allow

   

    // Please note : the structure of map in this function is according to the JSON data map of the jsTree

    @SuppressWarnings("unchecked")

    public static void getChildCategoryTree(HttpServletRequest request, HttpServletResponse response){

        String productCategoryId = request.getParameter("productCategoryId");

        String isCatalog = request.getParameter("isCatalog");

        String isCategoryType = request.getParameter("isCategoryType");

        String entityName = null;

        String primaryKeyName = null;

       

        if (isCatalog.equals("true")) {

            entityName = "ProdCatalog";

            primaryKeyName = "prodCatalogId";

        } else {

            entityName = "ProductCategory";

            primaryKeyName = "productCategoryId";

        }

       

        List categoryList = FastList.newInstance();

        List<GenericValue> childOfCats;

        List<String> sortList = org.ofbiz.base.util.UtilMisc.toList("sequenceNum", "title");

       

        try {

            if (UtilValidate.isNotEmpty(category)) {

                if (isCatalog.equals("true") && isCategoryType.equals("false")) {

                    CategoryWorker.getRelatedCategories(request, "ChildCatalogList", CatalogWorker.getCatalogTopCategoryId(request, productCategoryId), true);

                    childOfCats = EntityUtil.filterByDate((List<GenericValue>) request.getAttribute("ChildCatalogList"));

                   

                } else if(isCatalog.equals("false") && isCategoryType.equals("false")){

                            "parentProductCategoryId", productCategoryId )));

                } else {

                }

                if (UtilValidate.isNotEmpty(childOfCats)) {

                 

                    for (GenericValue childOfCat : childOfCats ) {

                       

                        Object catId = null;

                        String catNameField = null;

                       

                        catId = childOfCat.get("productCategoryId");

                        catNameField = "CATEGORY_NAME";

                       

                        Map josonMap = FastMap.newInstance();

                        List<GenericValue> childList = null;

                       

                        // Get the child list of chosen category

                                    "parentProductCategoryId", catId)));

                       

                        // Get the chosen category information for the categoryContentWrapper

                       

                        // If chosen category's child exists, then put the arrow before category icon

                        if (UtilValidate.isNotEmpty(childList)) {

                            josonMap.put("state", "closed");

                        }

    public static String module = EbayStoreCustomerService.class.getName();

    private static final String resource = "EbayStoreUiLabels";

    public static Map<String, Object> listBestOfferIncludeMessage(DispatchContext dctx, Map<String, ? extends Object> context) {

        Locale locale = (Locale) context.get("locale");

        if (UtilValidate.isEmpty(context.get("userId")) || UtilValidate.isEmpty(context.get("itemId"))) {

            return ServiceUtil.returnFailure(UtilProperties.getMessage(resource, "EbayStoreRequiredUserIdAndItemId", locale));

        }

        Map <String, Object> result = FastMap.newInstance();

        }

        return result;

    }

    public static Map<String, Object> updateContactStatus(DispatchContext dctx, Map<String, ? extends Object> context) {

        Locale locale = (Locale) context.get("locale");

        if (UtilValidate.isEmpty(context.get("productStoreId")) || UtilValidate.isEmpty(context.get("userId")) || UtilValidate.isEmpty(context.get("itemId")) || UtilValidate.isEmpty(context.get("offerId")) || UtilValidate.isEmpty(context.get("contactSetting"))) {

            return ServiceUtil.returnFailure(UtilProperties.getMessage(resource, "EbayStoreRequiredUserIdAndItemIdAndProductStoreIdAndOfferIdAndContactStatus", locale));

        }

        String userId = (String) context.get("userId");

        String itemId = (String) context.get("itemId");

        String itemName = (String) context.get("itemName");

        String productStoreId = (String) context.get("productStoreId");

        String offerId = (String) context.get("offerId");

        String contactStatus = (String) context.get("contactSetting");

        String price = (String) context.get("price");

        String email = (String) context.get("email");

        String quantity = (String) context.get("quantity");

        Map <String, Object> result = FastMap.newInstance();

        try {

            ApiContext apiContext = EbayStoreHelper.getApiContext(productStoreId, locale, delegator);

            String[] bestOfferIDs = {offerId};

            RespondToBestOfferCall respondToBestOfferCall = new RespondToBestOfferCall(apiContext);

            respondToBestOfferCall.setItemID(itemId);

            respondToBestOfferCall.setBestOfferIDs(bestOfferIDs);

            if (contactStatus.equals("ACCEPT")) {

                respondToBestOfferCall.setBestOfferAction(BestOfferActionCodeType.ACCEPT);

                respondToBestOfferCall.respondToBestOffer();

                contactStatus = "FINISHED";

            } else if (contactStatus.equals("DECLINE")) {

                respondToBestOfferCall.setBestOfferAction(BestOfferActionCodeType.DECLINE);

                respondToBestOfferCall.respondToBestOffer();

                contactStatus = "FINISHED";

            } else {

                return ServiceUtil.returnFailure(UtilProperties.getMessage(resource, "EbayStoreRequiredContactStatusSetting", locale));

            }

            ebayUserBestOffer.set("contactStatus", contactStatus);

            ebayUserBestOffer.store();

           

            result.put("userId", userId);

            result.put("itemId", itemId);

        }

        return result;

    }

    public static Map<String, Object> deleteContactAlert(DispatchContext dctx, Map<String, ? extends Object> context) {

        String productStoreId = (String) context.get("productStoreId");

        Locale locale = (Locale) context.get("locale");

        Map <String, Object> result = FastMap.newInstance();

        if (UtilValidate.isEmpty(context.get("itemId")) || UtilValidate.isEmpty(context.get("userId"))) {

            return ServiceUtil.returnFailure(UtilProperties.getMessage(resource, "EbayStoreRequiredUserIdAndItemId", locale));

        }

        String itemId = (String) context.get("itemId");

        String userId = (String) context.get("userId");

        try {

            ebayUserBestOffer.remove();

            result.put("productStoreId", productStoreId);

        } catch (Exception e) {

            return ServiceUtil.returnFailure(UtilProperties.getMessage(resource, "EbayStoreErrorFromDeleteContactStatus", locale) + e);

        }

        // UtilTimer utilTimer = new UtilTimer();

        // utilTimer.timerString("Starting price calc", module);

        // utilTimer.setLog(false);

        LocalDispatcher dispatcher = dctx.getDispatcher();

        Map<String, Object> result = FastMap.newInstance();

        Timestamp nowTimestamp = UtilDateTime.nowTimestamp();

        GenericValue product = (GenericValue) context.get("product");

        String productId = product.getString("productId");

        String prodCatalogId = (String) context.get("prodCatalogId");

        String webSiteId = (String) context.get("webSiteId");

        String checkIncludeVat = (String) context.get("checkIncludeVat");

        String surveyResponseId = (String) context.get("surveyResponseId");

        Map<String, Object> customAttributes = UtilGenerics.checkMap(context.get("customAttributes"));

        String findAllQuantityPricesStr = (String) context.get("findAllQuantityPrices");

        boolean findAllQuantityPrices = "Y".equals(findAllQuantityPricesStr);

        boolean optimizeForLargeRuleSet = "Y".equals(context.get("optimizeForLargeRuleSet"));

        String agreementId = (String) context.get("agreementId");

        String productStoreId = (String) context.get("productStoreId");

        String productStoreGroupId = (String) context.get("productStoreGroupId");

        Locale locale = (Locale) context.get("locale");

       

        GenericValue productStore = null;

        try {

            // we have a productStoreId, if the corresponding ProductStore.primaryStoreGroupId is not empty, use that

        } catch (GenericEntityException e) {

            Debug.logError(e, "Error getting product store info from the database while calculating price" + e.toString(), module);

            return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                    "ProductPriceCannotRetrieveProductStore", UtilMisc.toMap("errorString", e.toString()) , locale));

        }

        if (UtilValidate.isEmpty(productStoreGroupId)) {

            if (productStore != null) {

                try {

                    if (UtilValidate.isNotEmpty(productStore.getString("primaryStoreGroupId"))) {

                        productStoreGroupId = productStore.getString("primaryStoreGroupId");

                    } else {

                        // no ProductStore.primaryStoreGroupId, try ProductStoreGroupMember

                        productStoreGroupMemberList = EntityUtil.filterByDate(productStoreGroupMemberList, true);

                        if (productStoreGroupMemberList.size() > 0) {

                            GenericValue productStoreGroupMember = EntityUtil.getFirst(productStoreGroupMemberList);

                            productStoreGroupId = productStoreGroupMember.getString("productStoreGroupId");

                        }

                    }

                } catch (GenericEntityException e) {

                    Debug.logError(e, "Error getting product store info from the database while calculating price" + e.toString(), module);

                    return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                            "ProductPriceCannotRetrieveProductStore", UtilMisc.toMap("errorString", e.toString()) , locale));

                }

            }

            // still empty, default to _NA_

            if (UtilValidate.isEmpty(productStoreGroupId)) {

                productStoreGroupId = "_NA_";

            }

        }

        // if currencyUomId is null get from properties file, if nothing there assume USD (USD: American Dollar) for now

        String currencyUomId = (String) context.get("currencyUomId");

        if (UtilValidate.isEmpty(currencyUomId)) {

            currencyUomId = UtilProperties.getPropertyValue("general", "currency.uom.id.default", "USD");

        }

        // productPricePurposeId is null assume "PURCHASE", which is equivalent to what prices were before the purpose concept

        String productPricePurposeId = (String) context.get("productPricePurposeId");

        if (UtilValidate.isEmpty(productPricePurposeId)) {

            productPricePurposeId = "PURCHASE";

        }

        // termUomId, for things like recurring prices specifies the term (time/frequency measure for example) of the recurrence

        // if this is empty it will simply not be used to constrain the selection

        String termUomId = (String) context.get("termUomId");

        // if this product is variant, find the virtual product and apply checks to it as well

        String virtualProductId = null;

        if ("Y".equals(product.getString("isVariant"))) {

            try {

                virtualProductId = ProductWorker.getVariantVirtualId(product);

            } catch (GenericEntityException e) {

                Debug.logError(e, "Error getting virtual product id from the database while calculating price" + e.toString(), module);

                return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                        "ProductPriceCannotRetrieveVirtualProductId", UtilMisc.toMap("errorString", e.toString()) , locale));

            }

        }

        // get prices for virtual product if one is found; get all ProductPrice entities for this productId and currencyUomId

        List<GenericValue> virtualProductPrices = null;

        if (virtualProductId != null) {

            try {

            } catch (GenericEntityException e) {

                Debug.logError(e, "An error occurred while getting the product prices", module);

            }

            virtualProductPrices = EntityUtil.filterByDate(virtualProductPrices, true);

        }

        // NOTE: partyId CAN be null

        String partyId = (String) context.get("partyId");

        if (UtilValidate.isEmpty(partyId) && context.get("userLogin") != null) {

            GenericValue userLogin = (GenericValue) context.get("userLogin");

            partyId = userLogin.getString("partyId");

        }

        // check for auto-userlogin for price rules

        if (UtilValidate.isEmpty(partyId) && context.get("autoUserLogin") != null) {

            GenericValue userLogin = (GenericValue) context.get("autoUserLogin");

            partyId = userLogin.getString("partyId");

        }

        BigDecimal quantity = (BigDecimal) context.get("quantity");

        if (quantity == null) quantity = BigDecimal.ONE;

        BigDecimal amount = (BigDecimal) context.get("amount");

        List<EntityCondition> productPriceEcList = FastList.newInstance();

        productPriceEcList.add(EntityCondition.makeCondition("productId", EntityOperator.EQUALS, productId));

        // this funny statement is for backward compatibility purposes; the productPricePurposeId is a new pk field on the ProductPrice entity and in order databases may not be populated, until the pk is updated and such; this will ease the transition somewhat

        if ("PURCHASE".equals(productPricePurposeId)) {

            productPriceEcList.add(EntityCondition.makeCondition(

                    EntityCondition.makeCondition("productPricePurposeId", EntityOperator.EQUALS, productPricePurposeId),

                    EntityOperator.OR,

                    EntityCondition.makeCondition("productPricePurposeId", EntityOperator.EQUALS, null)));

        } else {

            productPriceEcList.add(EntityCondition.makeCondition("productPricePurposeId", EntityOperator.EQUALS, productPricePurposeId));

        }

        productPriceEcList.add(EntityCondition.makeCondition("currencyUomId", EntityOperator.EQUALS, currencyUomId));

        productPriceEcList.add(EntityCondition.makeCondition("productStoreGroupId", EntityOperator.EQUALS, productStoreGroupId));

        if (UtilValidate.isNotEmpty(termUomId)) {

            productPriceEcList.add(EntityCondition.makeCondition("termUomId", EntityOperator.EQUALS, termUomId));

        }

        EntityCondition productPriceEc = EntityCondition.makeCondition(productPriceEcList, EntityOperator.AND);

        // for prices, get all ProductPrice entities for this productId and currencyUomId

        List<GenericValue> productPrices = null;

        try {

        } catch (GenericEntityException e) {

            Debug.logError(e, "An error occurred while getting the product prices", module);

        }

        productPrices = EntityUtil.filterByDate(productPrices, true);

        // ===== get the prices we need: list, default, average cost, promo, min, max =====

        List<GenericValue> listPrices = EntityUtil.filterByAnd(productPrices, UtilMisc.toMap("productPriceTypeId", "LIST_PRICE"));

        GenericValue listPriceValue = EntityUtil.getFirst(listPrices);

        if (listPrices != null && listPrices.size() > 1) {

            if (Debug.infoOn()) Debug.logInfo("There is more than one LIST_PRICE with the currencyUomId " + currencyUomId + " and productId " + productId + ", using the latest found with price: " + listPriceValue.getBigDecimal("price"), module);

        }

        List<GenericValue> defaultPrices = EntityUtil.filterByAnd(productPrices, UtilMisc.toMap("productPriceTypeId", "DEFAULT_PRICE"));

        GenericValue defaultPriceValue = EntityUtil.getFirst(defaultPrices);

        if (defaultPrices != null && defaultPrices.size() > 1) {

            if (Debug.infoOn()) Debug.logInfo("There is more than one DEFAULT_PRICE with the currencyUomId " + currencyUomId + " and productId " + productId + ", using the latest found with price: " + defaultPriceValue.getBigDecimal("price"), module);

        }

        // If there is an agreement between the company and the client, and there is

        // a price for the product in it, it will override the default price of the

        // ProductPrice entity.

        if (UtilValidate.isNotEmpty(agreementId)) {

            try {

                GenericValue agreementPriceValue = EntityUtil.getFirst(agreementPrices);

                if (agreementPriceValue != null && agreementPriceValue.get("price") != null) {

                    defaultPriceValue = agreementPriceValue;

                }

            } catch (GenericEntityException e) {

                Debug.logError(e, "Error getting agreement info from the database while calculating price" + e.toString(), module);

                return ServiceUtil.returnError(UtilProperties.getMessage(resource,

                        "ProductPriceCannotRetrieveAgreementInfo", UtilMisc.toMap("errorString", e.toString()) , locale));

            }

        }

        List<GenericValue> competitivePrices = EntityUtil.filterByAnd(productPrices, UtilMisc.toMap("productPriceTypeId", "COMPETITIVE_PRICE"));

        GenericValue competitivePriceValue = EntityUtil.getFirst(competitivePrices);

        if (competitivePrices != null && competitivePrices.size() > 1) {

            if (Debug.infoOn()) Debug.logInfo("There is more than one COMPETITIVE_PRICE with the currencyUomId " + currencyUomId + " and productId " + productId + ", using the latest found with price: " + competitivePriceValue.getBigDecimal("price"), module);

        }

        List<GenericValue> averageCosts = EntityUtil.filterByAnd(productPrices, UtilMisc.toMap("productPriceTypeId", "AVERAGE_COST"));

        GenericValue averageCostValue = EntityUtil.getFirst(averageCosts);

        if (averageCosts != null && averageCosts.size() > 1) {

            if (Debug.infoOn()) Debug.logInfo("There is more than one AVERAGE_COST with the currencyUomId " + currencyUomId + " and productId " + productId + ", using the latest found with price: " + averageCostValue.getBigDecimal("price"), module);

        }

        List<GenericValue> promoPrices = EntityUtil.filterByAnd(productPrices, UtilMisc.toMap("productPriceTypeId", "PROMO_PRICE"));

        GenericValue promoPriceValue = EntityUtil.getFirst(promoPrices);

        if (promoPrices != null && promoPrices.size() > 1) {

            if (Debug.infoOn()) Debug.logInfo("There is more than one PROMO_PRICE with the currencyUomId " + currencyUomId + " and productId " + productId + ", using the latest found with price: " + promoPriceValue.getBigDecimal("price"), module);

        }

        List<GenericValue> minimumPrices = EntityUtil.filterByAnd(productPrices, UtilMisc.toMap("productPriceTypeId", "MINIMUM_PRICE"));

        GenericValue minimumPriceValue = EntityUtil.getFirst(minimumPrices);

        if (minimumPrices != null && minimumPrices.size() > 1) {

            if (Debug.infoOn()) Debug.logInfo("There is more than one MINIMUM_PRICE with the currencyUomId " + currencyUomId + " and productId " + productId + ", using the latest found with price: " + minimumPriceValue.getBigDecimal("price"), module);

        }

        List<GenericValue> maximumPrices = EntityUtil.filterByAnd(productPrices, UtilMisc.toMap("productPriceTypeId", "MAXIMUM_PRICE"));

        GenericValue maximumPriceValue = EntityUtil.getFirst(maximumPrices);

        if (maximumPrices != null && maximumPrices.size() > 1) {

            if (Debug.infoOn()) Debug.logInfo("There is more than one MAXIMUM_PRICE with the currencyUomId " + currencyUomId + " and productId " + productId + ", using the latest found with price: " + maximumPriceValue.getBigDecimal("price"), module);

        }

        List<GenericValue> wholesalePrices = EntityUtil.filterByAnd(productPrices, UtilMisc.toMap("productPriceTypeId", "WHOLESALE_PRICE"));

        GenericValue wholesalePriceValue = EntityUtil.getFirst(wholesalePrices);

        if (wholesalePrices != null && wholesalePrices.size() > 1) {

            if (Debug.infoOn()) Debug.logInfo("There is more than one WHOLESALE_PRICE with the currencyUomId " + currencyUomId + " and productId " + productId + ", using the latest found with price: " + wholesalePriceValue.getBigDecimal("price"), module);

        }

        List<GenericValue> specialPromoPrices = EntityUtil.filterByAnd(productPrices, UtilMisc.toMap("productPriceTypeId", "SPECIAL_PROMO_PRICE"));

        GenericValue specialPromoPriceValue = EntityUtil.getFirst(specialPromoPrices);

        if (specialPromoPrices != null && specialPromoPrices.size() > 1) {

            if (Debug.infoOn()) Debug.logInfo("There is more than one SPECIAL_PROMO_PRICE with the currencyUomId " + currencyUomId + " and productId " + productId + ", using the latest found with price: " + specialPromoPriceValue.getBigDecimal("price"), module);

        }

        // if any of these prices is missing and this product is a variant, default to the corresponding price on the virtual product

        if (UtilValidate.isNotEmpty(virtualProductPrices)) {

            if (listPriceValue == null) {

                List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(virtualProductPrices, UtilMisc.toMap("productPriceTypeId", "LIST_PRICE"));

                listPriceValue = EntityUtil.getFirst(virtualTempPrices);

                if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                    if (Debug.infoOn()) Debug.logInfo("There is more than one LIST_PRICE with the currencyUomId " + currencyUomId + " and productId " + virtualProductId + ", using the latest found with price: " + listPriceValue.getBigDecimal("price"), module);

                }

            }

            if (defaultPriceValue == null) {

                List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(virtualProductPrices, UtilMisc.toMap("productPriceTypeId", "DEFAULT_PRICE"));

                defaultPriceValue = EntityUtil.getFirst(virtualTempPrices);

                if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                    if (Debug.infoOn()) Debug.logInfo("There is more than one DEFAULT_PRICE with the currencyUomId " + currencyUomId + " and productId " + virtualProductId + ", using the latest found with price: " + defaultPriceValue.getBigDecimal("price"), module);

                }

            }

            if (averageCostValue == null) {

                List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(virtualProductPrices, UtilMisc.toMap("productPriceTypeId", "AVERAGE_COST"));

                averageCostValue = EntityUtil.getFirst(virtualTempPrices);

                if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                    if (Debug.infoOn()) Debug.logInfo("There is more than one AVERAGE_COST with the currencyUomId " + currencyUomId + " and productId " + virtualProductId + ", using the latest found with price: " + averageCostValue.getBigDecimal("price"), module);

                }

            }

            if (promoPriceValue == null) {

                List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(virtualProductPrices, UtilMisc.toMap("productPriceTypeId", "PROMO_PRICE"));

                promoPriceValue = EntityUtil.getFirst(virtualTempPrices);

                if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                    if (Debug.infoOn()) Debug.logInfo("There is more than one PROMO_PRICE with the currencyUomId " + currencyUomId + " and productId " + virtualProductId + ", using the latest found with price: " + promoPriceValue.getBigDecimal("price"), module);

                }

            }

            if (minimumPriceValue == null) {

                List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(virtualProductPrices, UtilMisc.toMap("productPriceTypeId", "MINIMUM_PRICE"));

                minimumPriceValue = EntityUtil.getFirst(virtualTempPrices);

                if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                    if (Debug.infoOn()) Debug.logInfo("There is more than one MINIMUM_PRICE with the currencyUomId " + currencyUomId + " and productId " + virtualProductId + ", using the latest found with price: " + minimumPriceValue.getBigDecimal("price"), module);

                }

            }

            if (maximumPriceValue == null) {

                List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(virtualProductPrices, UtilMisc.toMap("productPriceTypeId", "MAXIMUM_PRICE"));

                maximumPriceValue = EntityUtil.getFirst(virtualTempPrices);

                if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                    if (Debug.infoOn()) Debug.logInfo("There is more than one MAXIMUM_PRICE with the currencyUomId " + currencyUomId + " and productId " + virtualProductId + ", using the latest found with price: " + maximumPriceValue.getBigDecimal("price"), module);

                }

            }

            if (wholesalePriceValue == null) {

                List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(virtualProductPrices, UtilMisc.toMap("productPriceTypeId", "WHOLESALE_PRICE"));

                wholesalePriceValue = EntityUtil.getFirst(virtualTempPrices);

                if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                    if (Debug.infoOn()) Debug.logInfo("There is more than one WHOLESALE_PRICE with the currencyUomId " + currencyUomId + " and productId " + virtualProductId + ", using the latest found with price: " + wholesalePriceValue.getBigDecimal("price"), module);

                }

            }

            if (specialPromoPriceValue == null) {

                List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(virtualProductPrices, UtilMisc.toMap("productPriceTypeId", "SPECIAL_PROMO_PRICE"));

                specialPromoPriceValue = EntityUtil.getFirst(virtualTempPrices);

                if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                    if (Debug.infoOn()) Debug.logInfo("There is more than one SPECIAL_PROMO_PRICE with the currencyUomId " + currencyUomId + " and productId " + virtualProductId + ", using the latest found with price: " + specialPromoPriceValue.getBigDecimal("price"), module);

                }

            }

        }

        // now if this is a virtual product check each price type, if doesn't exist get from variant with lowest DEFAULT_PRICE

        if ("Y".equals(product.getString("isVirtual"))) {

            // only do this if there is no default price, consider the others optional for performance reasons

            if (defaultPriceValue == null) {

                // Debug.logInfo("Product isVirtual and there is no default price for ID " + productId + ", trying variant prices", module);

                //use the cache to find the variant with the lowest default price

                try {

                    BigDecimal minDefaultPrice = null;

                    List<GenericValue> variantProductPrices = null;

                    String variantProductId = null;

                    for (GenericValue variantAssoc: variantAssocList) {

                        String curVariantProductId = variantAssoc.getString("productIdTo");

                        List<GenericValue> tempDefaultPriceList = EntityUtil.filterByAnd(curVariantPriceList, UtilMisc.toMap("productPriceTypeId", "DEFAULT_PRICE"));

                        GenericValue curDefaultPriceValue = EntityUtil.getFirst(tempDefaultPriceList);

                        if (curDefaultPriceValue != null) {

                            BigDecimal curDefaultPrice = curDefaultPriceValue.getBigDecimal("price");

                            if (minDefaultPrice == null || curDefaultPrice.compareTo(minDefaultPrice) < 0) {

                                // check to see if the product is discontinued for sale before considering it the lowest price

                                if (curVariantProduct != null) {

                                    Timestamp salesDiscontinuationDate = curVariantProduct.getTimestamp("salesDiscontinuationDate");

                                    if (salesDiscontinuationDate == null || salesDiscontinuationDate.after(nowTimestamp)) {

                                        minDefaultPrice = curDefaultPrice;

                                        variantProductPrices = curVariantPriceList;

                                        variantProductId = curVariantProductId;

                                        // Debug.logInfo("Found new lowest price " + minDefaultPrice + " for variant with ID " + variantProductId, module);

                                    }

                                }

                            }

                        }

                    }

                    if (variantProductPrices != null) {

                        // we have some other options, give 'em a go...

                        if (listPriceValue == null) {

                            List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(variantProductPrices, UtilMisc.toMap("productPriceTypeId", "LIST_PRICE"));

                            listPriceValue = EntityUtil.getFirst(virtualTempPrices);

                            if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                                if (Debug.infoOn()) Debug.logInfo("There is more than one LIST_PRICE with the currencyUomId " + currencyUomId + " and productId " + variantProductId + ", using the latest found with price: " + listPriceValue.getBigDecimal("price"), module);

                            }

                        }

                        if (defaultPriceValue == null) {

                            List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(variantProductPrices, UtilMisc.toMap("productPriceTypeId", "DEFAULT_PRICE"));

                            defaultPriceValue = EntityUtil.getFirst(virtualTempPrices);

                            if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                                if (Debug.infoOn()) Debug.logInfo("There is more than one DEFAULT_PRICE with the currencyUomId " + currencyUomId + " and productId " + variantProductId + ", using the latest found with price: " + defaultPriceValue.getBigDecimal("price"), module);

                            }

                        }

                        if (competitivePriceValue == null) {

                            List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(variantProductPrices, UtilMisc.toMap("productPriceTypeId", "COMPETITIVE_PRICE"));

                            competitivePriceValue = EntityUtil.getFirst(virtualTempPrices);

                            if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                                if (Debug.infoOn()) Debug.logInfo("There is more than one COMPETITIVE_PRICE with the currencyUomId " + currencyUomId + " and productId " + variantProductId + ", using the latest found with price: " + competitivePriceValue.getBigDecimal("price"), module);

                            }

                        }

                        if (averageCostValue == null) {

                            List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(variantProductPrices, UtilMisc.toMap("productPriceTypeId", "AVERAGE_COST"));

                            averageCostValue = EntityUtil.getFirst(virtualTempPrices);

                            if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                                if (Debug.infoOn()) Debug.logInfo("There is more than one AVERAGE_COST with the currencyUomId " + currencyUomId + " and productId " + variantProductId + ", using the latest found with price: " + averageCostValue.getBigDecimal("price"), module);

                            }

                        }

                        if (promoPriceValue == null) {

                            List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(variantProductPrices, UtilMisc.toMap("productPriceTypeId", "PROMO_PRICE"));

                            promoPriceValue = EntityUtil.getFirst(virtualTempPrices);

                            if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                                if (Debug.infoOn()) Debug.logInfo("There is more than one PROMO_PRICE with the currencyUomId " + currencyUomId + " and productId " + variantProductId + ", using the latest found with price: " + promoPriceValue.getBigDecimal("price"), module);

                            }

                        }

                        if (minimumPriceValue == null) {

                            List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(variantProductPrices, UtilMisc.toMap("productPriceTypeId", "MINIMUM_PRICE"));

                            minimumPriceValue = EntityUtil.getFirst(virtualTempPrices);

                            if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                                if (Debug.infoOn()) Debug.logInfo("There is more than one MINIMUM_PRICE with the currencyUomId " + currencyUomId + " and productId " + variantProductId + ", using the latest found with price: " + minimumPriceValue.getBigDecimal("price"), module);

                            }

                        }

                        if (maximumPriceValue == null) {

                            List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(variantProductPrices, UtilMisc.toMap("productPriceTypeId", "MAXIMUM_PRICE"));

                            maximumPriceValue = EntityUtil.getFirst(virtualTempPrices);

                            if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                                if (Debug.infoOn()) Debug.logInfo("There is more than one MAXIMUM_PRICE with the currencyUomId " + currencyUomId + " and productId " + variantProductId + ", using the latest found with price: " + maximumPriceValue.getBigDecimal("price"), module);

                            }

                        }

                        if (wholesalePriceValue == null) {

                            List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(variantProductPrices, UtilMisc.toMap("productPriceTypeId", "WHOLESALE_PRICE"));

                            wholesalePriceValue = EntityUtil.getFirst(virtualTempPrices);

                            if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                                if (Debug.infoOn()) Debug.logInfo("There is more than one WHOLESALE_PRICE with the currencyUomId " + currencyUomId + " and productId " + variantProductId + ", using the latest found with price: " + wholesalePriceValue.getBigDecimal("price"), module);

                            }

                        }

                        if (specialPromoPriceValue == null) {

                            List<GenericValue> virtualTempPrices = EntityUtil.filterByAnd(variantProductPrices, UtilMisc.toMap("productPriceTypeId", "SPECIAL_PROMO_PRICE"));

                            specialPromoPriceValue = EntityUtil.getFirst(virtualTempPrices);

                            if (virtualTempPrices != null && virtualTempPrices.size() > 1) {

                                if (Debug.infoOn()) Debug.logInfo("There is more than one SPECIAL_PROMO_PRICE with the currencyUomId " + currencyUomId + " and productId " + variantProductId + ", using the latest found with price: " + wholesalePriceValue.getBigDecimal("price"), module);

                            }

                        }

                    }

                } catch (GenericEntityException e) {

                    Debug.logError(e, "An error occurred while getting the product prices", module);

                }

            }

        }

        //boolean validPromoPriceFound = false;

        BigDecimal promoPrice = BigDecimal.ZERO;

        if (promoPriceValue != null && promoPriceValue.get("price") != null) {

            promoPrice = promoPriceValue.getBigDecimal("price");

            //validPromoPriceFound = true;

        }

        //boolean validWholesalePriceFound = false;

        BigDecimal wholesalePrice = BigDecimal.ZERO;

        if (wholesalePriceValue != null && wholesalePriceValue.get("price") != null) {

            wholesalePrice = wholesalePriceValue.getBigDecimal("price");

            //validWholesalePriceFound = true;

        }

        boolean validPriceFound = false;

        BigDecimal defaultPrice = BigDecimal.ZERO;

        List<GenericValue> orderItemPriceInfos = FastList.newInstance();

        if (defaultPriceValue != null) {

            // If a price calc formula (service) is specified, then use it to get the unit price

            if ("ProductPrice".equals(defaultPriceValue.getEntityName()) && UtilValidate.isNotEmpty(defaultPriceValue.getString("customPriceCalcService"))) {

                GenericValue customMethod = null;

                try {

                    customMethod = defaultPriceValue.getRelatedOne("CustomMethod");

                } catch (GenericEntityException gee) {

                    Debug.logError(gee, "An error occurred while getting the customPriceCalcService", module);

                }

                if (UtilValidate.isNotEmpty(customMethod) && UtilValidate.isNotEmpty(customMethod.getString("customMethodName"))) {

                    Map<String, Object> inMap = UtilMisc.toMap("userLogin", context.get("userLogin"), "product", product);

                    inMap.put("initialPrice", defaultPriceValue.getBigDecimal("price"));

                    inMap.put("currencyUomId", currencyUomId);

                    inMap.put("quantity", quantity);

                    inMap.put("amount", amount);

                    if (UtilValidate.isNotEmpty(surveyResponseId)) {

                        inMap.put("surveyResponseId", surveyResponseId);

                    }

                    if (UtilValidate.isNotEmpty(customAttributes)) {

                        inMap.put("customAttributes", customAttributes);

                    }

                    try {

                        Map<String, Object> outMap = dispatcher.runSync(customMethod.getString("customMethodName"), inMap);

                        if (!ServiceUtil.isError(outMap)) {

                            BigDecimal calculatedDefaultPrice = (BigDecimal)outMap.get("price");

                            orderItemPriceInfos = UtilGenerics.checkList(outMap.get("orderItemPriceInfos"));

                            if (UtilValidate.isNotEmpty(calculatedDefaultPrice)) {

                                defaultPrice = calculatedDefaultPrice;

                                validPriceFound = true;

                            }

                        }

                    } catch (GenericServiceException gse) {

                        Debug.logError(gse, "An error occurred while running the customPriceCalcService [" + customMethod.getString("customMethodName") + "]", module);

                    }

                }

            }

            if (!validPriceFound && defaultPriceValue.get("price") != null) {

                defaultPrice = defaultPriceValue.getBigDecimal("price");

                validPriceFound = true;

            }

        }

        BigDecimal listPrice = listPriceValue != null ? listPriceValue.getBigDecimal("price") : null;

        if (listPrice == null) {

            // no list price, use defaultPrice for the final price

            // ========= ensure calculated price is not below minSalePrice or above maxSalePrice =========

            BigDecimal maxSellPrice = maximumPriceValue != null ? maximumPriceValue.getBigDecimal("price") : null;

            if (maxSellPrice != null && defaultPrice.compareTo(maxSellPrice) > 0) {

                defaultPrice = maxSellPrice;

            }

            // min price second to override max price, safety net

            BigDecimal minSellPrice = minimumPriceValue != null ? minimumPriceValue.getBigDecimal("price") : null;

            if (minSellPrice != null && defaultPrice.compareTo(minSellPrice) < 0) {

                defaultPrice = minSellPrice;

                // since we have found a minimum price that has overriden a the defaultPrice, even if no valid one was found, we will consider it as if one had been...

                validPriceFound = true;

            }

            result.put("basePrice", defaultPrice);

            result.put("price", defaultPrice);

            result.put("defaultPrice", defaultPrice);

            result.put("competitivePrice", competitivePriceValue != null ? competitivePriceValue.getBigDecimal("price") : null);

            result.put("averageCost", averageCostValue != null ? averageCostValue.getBigDecimal("price") : null);

            result.put("promoPrice", promoPriceValue != null ? promoPriceValue.getBigDecimal("price") : null);

            result.put("specialPromoPrice", specialPromoPriceValue != null ? specialPromoPriceValue.getBigDecimal("price") : null);

            result.put("validPriceFound", Boolean.valueOf(validPriceFound));

            result.put("isSale", Boolean.FALSE);

            result.put("orderItemPriceInfos", orderItemPriceInfos);

            Map<String, Object> errorResult = addGeneralResults(result, competitivePriceValue, specialPromoPriceValue, productStore,

                    checkIncludeVat, currencyUomId, productId, quantity, partyId, dispatcher, locale);

            if (errorResult != null) return errorResult;

        } else {

            try {

                List<GenericValue> allProductPriceRules = makeProducePriceRuleList(delegator, optimizeForLargeRuleSet, productId, virtualProductId, prodCatalogId, productStoreGroupId, webSiteId, partyId, currencyUomId);

                allProductPriceRules = EntityUtil.filterByDate(allProductPriceRules, true);

                List<GenericValue> quantityProductPriceRules = null;

                List<GenericValue> nonQuantityProductPriceRules = null;

                if (findAllQuantityPrices) {

                    // split into list with quantity conditions and list without, then iterate through each quantity cond one

                    quantityProductPriceRules = FastList.newInstance();

                    nonQuantityProductPriceRules = FastList.newInstance();

                    for (GenericValue productPriceRule: allProductPriceRules) {

                        boolean foundQuantityInputParam = false;

                        // only consider a rule if all conditions except the quantity condition are true

                        boolean allExceptQuantTrue = true;

                        for (GenericValue productPriceCond: productPriceCondList) {

        return ServiceUtil.returnSuccess(bankOfNumbers.toString());

    }

    public static Map<String, Object> purgeOldStoreAutoPromos(DispatchContext dctx, Map<String, ? extends Object> context) {

        String productStoreId = (String) context.get("productStoreId");

        Locale locale = (Locale) context.get("locale");

        Timestamp nowTimestamp = UtilDateTime.nowTimestamp();

        List<EntityCondition> condList = FastList.newInstance();

        if (UtilValidate.isEmpty(productStoreId)) {

            condList.add(EntityCondition.makeCondition("productStoreId", EntityOperator.EQUALS, productStoreId));

        }

        condList.add(EntityCondition.makeCondition("userEntered", EntityOperator.EQUALS, "Y"));

        condList.add(EntityCondition.makeCondition("thruDate", EntityOperator.NOT_EQUAL, null));

        condList.add(EntityCondition.makeCondition("thruDate", EntityOperator.LESS_THAN, nowTimestamp));

        EntityCondition cond = EntityCondition.makeCondition(condList, EntityOperator.AND);

        try {

            GenericValue productStorePromoAndAppl = null;

            while ((productStorePromoAndAppl = eli.next()) != null) {

                productStorePromo.setAllFields(productStorePromoAndAppl, true, null, null);

                productStorePromo.remove();

            }

            eli.close();

        } catch (GenericEntityException e) {

    /**

     * Calculates the purchase price of a product

     */

    public static Map<String, Object> calculatePurchasePrice(DispatchContext dctx, Map<String, ? extends Object> context) {

        LocalDispatcher dispatcher = dctx.getDispatcher();

        Map<String, Object> result = FastMap.newInstance();

        List<GenericValue> orderItemPriceInfos = FastList.newInstance();

        boolean validPriceFound = false;

        BigDecimal price = BigDecimal.ZERO;

        GenericValue product = (GenericValue)context.get("product");

        String productId = product.getString("productId");

        String currencyUomId = (String)context.get("currencyUomId");

        String partyId = (String)context.get("partyId");

        BigDecimal quantity = (BigDecimal)context.get("quantity");

        Locale locale = (Locale)context.get("locale");

        // a) Get the Price from the Agreement* data model

        // TODO: Implement this

        // b) If no price can be found, get the lastPrice from the SupplierProduct entity

        if (!validPriceFound) {

            Map<String, Object> priceContext = UtilMisc.toMap("currencyUomId", currencyUomId, "partyId", partyId, "productId", productId, "quantity", quantity);

            List<GenericValue> productSuppliers = null;

            try {

                Map<String, Object> priceResult = dispatcher.runSync("getSuppliersForProduct", priceContext);

                if (ServiceUtil.isError(priceResult)) {

                    String errMsg = ServiceUtil.getErrorMessage(priceResult);

                    Debug.logError(errMsg, module);

                    return ServiceUtil.returnError(errMsg);

                }

                productSuppliers = UtilGenerics.checkList(priceResult.get("supplierProducts"));

            } catch (GenericServiceException gse) {

                Debug.logError(gse, module);

                return ServiceUtil.returnError(gse.getMessage());

            }

            if (productSuppliers != null) {

                for (GenericValue productSupplier: productSuppliers) {

                    if (!validPriceFound) {

                        price = ((BigDecimal)productSupplier.get("lastPrice"));

                        validPriceFound = true;

                    }

                    // add a orderItemPriceInfo element too, without orderId or orderItemId

                    StringBuilder priceInfoDescription = new StringBuilder();

                    priceInfoDescription.append(UtilProperties.getMessage(resource, "ProductSupplier", locale));

                    priceInfoDescription.append(" [");

                    priceInfoDescription.append(UtilProperties.getMessage(resource, "ProductSupplierMinimumOrderQuantity", locale));

                    priceInfoDescription.append(productSupplier.getBigDecimal("minimumOrderQuantity"));

                    priceInfoDescription.append(UtilProperties.getMessage(resource, "ProductSupplierLastPrice", locale));

                    priceInfoDescription.append(productSupplier.getBigDecimal("lastPrice"));

                    priceInfoDescription.append("]");

                    //orderItemPriceInfo.set("productPriceRuleId", productPriceAction.get("productPriceRuleId"));

                    //orderItemPriceInfo.set("productPriceActionSeqId", productPriceAction.get("productPriceActionSeqId"));

                    //orderItemPriceInfo.set("modifyAmount", modifyAmount);

                    // make sure description is <= than 250 chars

                    String priceInfoDescriptionString = priceInfoDescription.toString();

                    if (priceInfoDescriptionString.length() > 250) {

                        priceInfoDescriptionString = priceInfoDescriptionString.substring(0, 250);

                    }

                    orderItemPriceInfo.set("description", priceInfoDescriptionString);

                    orderItemPriceInfos.add(orderItemPriceInfo);

                }

            }

        }

        // c) If no price can be found, get the averageCost from the ProductPrice entity

        if (!validPriceFound) {

            List<GenericValue> prices = null;

            try {

                        "productPricePurposeId", "PURCHASE"), UtilMisc.toList("-fromDate"));

                // if no prices are found; find the prices of the parent product

                if (UtilValidate.isEmpty(prices)) {

                    GenericValue parentProduct = ProductWorker.getParentProduct(productId, delegator);

                    if (parentProduct != null) {

                        String parentProductId = parentProduct.getString("productId");

                                "productPricePurposeId", "PURCHASE"), UtilMisc.toList("-fromDate"));

                    }

                }

            } catch (GenericEntityException e) {

                Debug.logError(e, module);

        return result;

    }

   

    public static Map<String, Object> EbayStoreCreateTransactionShoppingCart(DispatchContext dctx, Map<String, Object> context) {

        LocalDispatcher dispatcher = dctx.getDispatcher();

        Locale locale = (Locale) context.get("locale");

        GenericValue userLogin = (GenericValue) context.get("userLogin");

        Map<String, Object> result = FastMap.newInstance();

       

        String productStoreId = context.get("productStoreId").toString();

        String defaultCurrencyUomId = "";

        String payToPartyId = "";

        String facilityId = "";

       

        try {

            if (UtilValidate.isEmpty(productStoreId)) {

                return ServiceUtil.returnFailure(UtilProperties.getMessage(resource, "ordersImportFromEbay.productStoreIdIsMandatory", locale));

            } else {

                if (UtilValidate.isNotEmpty(productStore)) {

                    defaultCurrencyUomId = productStore.getString("defaultCurrencyUomId");

                    payToPartyId = productStore.getString("payToPartyId");

                    facilityId = productStore.getString("inventoryFacilityId");

                } else {

                    return ServiceUtil.returnFailure(UtilProperties.getMessage(resource, "ordersImportFromEbay.productStoreIdIsMandatory", locale));

                }

            }

           

            ShoppingCart cart = new ShoppingCart(delegator, productStoreId, locale, defaultCurrencyUomId);

            String externalId = context.get("externalId").toString();

            if (UtilValidate.isNotEmpty(externalId)) {

                cart.setExternalId(externalId);

            } else {

                return ServiceUtil.returnFailure(UtilProperties.getMessage(resource, "EbayStoreOrder.externalIdNotAvailable", locale));

            }

            cart.setOrderType("SALES_ORDER");

            cart.setChannelType("EBAY_SALES_CHANNEL");

            cart.setUserLogin(userLogin, dispatcher);

            cart.setProductStoreId(productStoreId);

            if (UtilValidate.isNotEmpty(facilityId)) {

                cart.setFacilityId(facilityId);

            }

            String amountStr = context.get("amountPaid").toString();

            BigDecimal amountPaid = new BigDecimal(amountStr);

            if (UtilValidate.isNotEmpty(amountPaid)) {

                amountPaid = new BigDecimal(amountStr);

            }

            cart.addPaymentAmount("EXT_EBAY", amountPaid, externalId, null, true, false, false);

            Timestamp orderDate = UtilDateTime.nowTimestamp();

            if (UtilValidate.isNotEmpty(context.get("createdDate"))) {

                SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");

                Date createdDate = dateFormat.parse((String) context.get("createdDate"));

                orderDate = new Timestamp(createdDate.getTime());

            }

            cart.setOrderDate(orderDate);

            String productId = context.get("productId").toString();

            if (UtilValidate.isEmpty(productId)) {

                return ServiceUtil.returnFailure(UtilProperties.getMessage(resource, "ordersImportFromEbay.productIdNotAvailable", locale));

            } else {

                if (UtilValidate.isEmpty(product)) {

                    return ServiceUtil.returnFailure(UtilProperties.getMessage(resource, "ordersImportFromEbay.productIdDoesNotExist", locale));

                }

            }

            if (UtilValidate.isEmpty(context.get("paidTime"))) {

                return ServiceUtil.returnFailure(UtilProperties.getMessage(resource, "ordersImportFromEbay.paymentIsStillNotReceived", locale));

            }

            BigDecimal unitPrice = new BigDecimal(context.get("transactionPrice").toString());

            BigDecimal quantity = new BigDecimal(context.get("quantityPurchased").toString());

            cart.addItemToEnd(productId, null, quantity, unitPrice, null, null, null, "PRODUCT_ORDER_ITEM", dispatcher, Boolean.FALSE, Boolean.FALSE);

            if (UtilValidate.isNotEmpty(payToPartyId)) {

                cart.setBillFromVendorPartyId(payToPartyId);

            }

            String shippingCost = context.get("shippingServiceCost").toString();

            if (UtilValidate.isNotEmpty(shippingCost)) {

                BigDecimal shippingAmount = new BigDecimal(shippingCost);