/** * Retrieves a group of user preferences from persistent storage. Call with userPrefGroupTypeId * and optional userPrefLoginId. If userPrefLoginId isn't specified, then the currently logged-in * user's userLoginId will be used. The retrieved preferences group is contained in the * <b>userPrefMap</b> element. * * @param ctx The DispatchContext that this service is operating in. * @param context Map containing the input arguments. * @return Map with the result of the service, the output parameters. */ public static Map<String, Object> getUserPreferenceGroup( DispatchContext ctx, Map<String, ?> context) { Locale locale = (Locale) context.get("locale"); if (!PreferenceWorker.isValidGetId(ctx, context)) { return ServiceUtil.returnError( UtilProperties.getMessage(resource, "getPreference.permissionError", locale)); } Delegator delegator = ctx.getDelegator(); String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId"); if (UtilValidate.isEmpty(userPrefGroupTypeId)) { return ServiceUtil.returnError( UtilProperties.getMessage(resource, "getPreference.invalidArgument", locale)); } String userLoginId = PreferenceWorker.getUserLoginId(context, true); Map<String, Object> userPrefMap = null; try { Map<String, String> fieldMap = UtilMisc.toMap("userLoginId", "_NA_", "userPrefGroupTypeId", userPrefGroupTypeId); userPrefMap = PreferenceWorker.createUserPrefMap(delegator.findByAnd("UserPreference", fieldMap)); fieldMap.put("userLoginId", userLoginId); userPrefMap.putAll( PreferenceWorker.createUserPrefMap(delegator.findByAnd("UserPreference", fieldMap))); } catch (GenericEntityException e) { Debug.logWarning(e.getMessage(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "getPreference.readFailure", new Object[] {e.getMessage()}, locale)); } catch (GeneralException e) { Debug.logWarning(e.getMessage(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "getPreference.readFailure", new Object[] {e.getMessage()}, locale)); } // for the 'DEFAULT' values find the related values in general properties and if found use // those. Iterator it = userPrefMap.entrySet().iterator(); Map generalProperties = UtilProperties.getProperties("general"); while (it.hasNext()) { Map.Entry pairs = (Map.Entry) it.next(); if ("DEFAULT".equals(pairs.getValue())) { if (UtilValidate.isNotEmpty(generalProperties.get(pairs.getKey()))) { userPrefMap.put((String) pairs.getKey(), generalProperties.get(pairs.getKey())); } } } Map<String, Object> result = ServiceUtil.returnSuccess(); result.put("userPrefMap", userPrefMap); return result; }
public static List<Map<String, GenericValue>> getPartyPaymentMethodValueMaps( Delegator delegator, String partyId, Boolean showOld) { List<Map<String, GenericValue>> paymentMethodValueMaps = FastList.newInstance(); try { List<GenericValue> paymentMethods = delegator.findByAnd("PaymentMethod", UtilMisc.toMap("partyId", partyId)); if (!showOld) paymentMethods = EntityUtil.filterByDate(paymentMethods, true); for (GenericValue paymentMethod : paymentMethods) { Map<String, GenericValue> valueMap = FastMap.newInstance(); paymentMethodValueMaps.add(valueMap); valueMap.put("paymentMethod", paymentMethod); if ("CREDIT_CARD".equals(paymentMethod.getString("paymentMethodTypeId"))) { GenericValue creditCard = paymentMethod.getRelatedOne("CreditCard"); if (creditCard != null) valueMap.put("creditCard", creditCard); } else if ("GIFT_CARD".equals(paymentMethod.getString("paymentMethodTypeId"))) { GenericValue giftCard = paymentMethod.getRelatedOne("GiftCard"); if (giftCard != null) valueMap.put("giftCard", giftCard); } else if ("EFT_ACCOUNT".equals(paymentMethod.getString("paymentMethodTypeId"))) { GenericValue eftAccount = paymentMethod.getRelatedOne("EftAccount"); if (eftAccount != null) valueMap.put("eftAccount", eftAccount); } } } catch (GenericEntityException e) { Debug.logWarning(e, module); } return paymentMethodValueMaps; }
public static boolean isBinComplete(Delegator delegator, String picklistBinId) throws GeneralException { // lookup the items in the bin List<GenericValue> items; try { items = delegator.findByAnd("PicklistItem", UtilMisc.toMap("picklistBinId", picklistBinId)); } catch (GenericEntityException e) { Debug.logError(e, module); throw e; } if (!UtilValidate.isEmpty(items)) { for (GenericValue v : items) { String itemStatus = v.getString("itemStatusId"); if (itemStatus != null) { if (!"PICKITEM_COMPLETED".equals(itemStatus)) { return false; } } } return true; } return false; }
/** * Retrieve the last deactivation date if the party is currently deactivated. * * @param partyId * @param delegator * @return the timestamp of last deactivation, null if the party is not deactivated * @throws GenericEntityNotFoundException */ public static Timestamp getDeactivationDate(String partyId, Delegator delegator) throws GenericEntityException { // check party current status: if (isActive(partyId, delegator)) { return null; } // party is currently deactivated, get the deactivation date try { List<GenericValue> deactivationDates = delegator.findByAnd( "PartyDeactivation", UtilMisc.toMap("partyId", partyId), UtilMisc.toList("-deactivationTimestamp")); if (UtilValidate.isNotEmpty(deactivationDates)) { return (Timestamp) deactivationDates.get(0).get("deactivationTimestamp"); } else { Debug.logWarning( "The party [" + partyId + "] status is disabled but there is no registered deactivation date.", MODULE); } } catch (GenericEntityException e) { Debug.logError(e, MODULE); } return null; }
/** Checks if the given party with role is assigned to the user login. */ public static boolean isAssignedToUserLogin( String partyId, String roleTypeId, GenericValue userLogin) throws GenericEntityException { Delegator delegator = userLogin.getDelegator(); String roleTypeIdTo = getFirstValidTeamMemberRoleTypeId(userLogin.getString("partyId"), delegator); if (roleTypeIdTo == null) { return false; } List<GenericValue> activeRelationships = EntityUtil.filterByDate( delegator.findByAnd( "PartyRelationship", UtilMisc.toMap( "partyIdFrom", partyId, "roleTypeIdFrom", roleTypeId, "partyIdTo", userLogin.get("partyId"), "roleTypeIdTo", roleTypeIdTo, "partyRelationshipTypeId", "ASSIGNED_TO"))); return activeRelationships.size() > 0; }
/** * Copies a user preference group. Call with fromUserLoginId, userPrefGroupTypeId and optional * userPrefLoginId. If userPrefLoginId isn't specified, then the currently logged-in user's * userLoginId will be used. * * @param ctx The DispatchContext that this service is operating in. * @param context Map containing the input arguments. * @return Map with the result of the service, the output parameters. */ public static Map<String, Object> copyUserPreferenceGroup( DispatchContext ctx, Map<String, ?> context) { Delegator delegator = ctx.getDelegator(); Locale locale = (Locale) context.get("locale"); String userLoginId = PreferenceWorker.getUserLoginId(context, false); String fromUserLoginId = (String) context.get("fromUserLoginId"); String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId"); if (UtilValidate.isEmpty(userLoginId) || UtilValidate.isEmpty(userPrefGroupTypeId) || UtilValidate.isEmpty(fromUserLoginId)) { return ServiceUtil.returnError( UtilProperties.getMessage(resource, "copyPreference.invalidArgument", locale)); } try { Map<String, String> fieldMap = UtilMisc.toMap( "userLoginId", fromUserLoginId, "userPrefGroupTypeId", userPrefGroupTypeId); List<GenericValue> resultList = delegator.findByAnd("UserPreference", fieldMap); if (resultList != null) { for (GenericValue preference : resultList) { preference.set("userLoginId", userLoginId); } delegator.storeAll(resultList); } } catch (GenericEntityException e) { Debug.logWarning(e.getMessage(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "copyPreference.writeFailure", new Object[] {e.getMessage()}, locale)); } return ServiceUtil.returnSuccess(); }
public static GenericValue getPaymentAddress(Delegator delegator, String partyId) { List<GenericValue> paymentAddresses = null; try { paymentAddresses = delegator.findByAnd( "PartyContactMechPurpose", UtilMisc.toMap("partyId", partyId, "contactMechPurposeTypeId", "PAYMENT_LOCATION"), UtilMisc.toList("-fromDate")); paymentAddresses = EntityUtil.filterByDate(paymentAddresses); } catch (GenericEntityException e) { Debug.logError(e, "Trouble getting PartyContactMechPurpose entity list", module); } // get the address for the primary contact mech GenericValue purpose = EntityUtil.getFirst(paymentAddresses); GenericValue postalAddress = null; if (purpose != null) { try { postalAddress = delegator.findByPrimaryKey( "PostalAddress", UtilMisc.toMap("contactMechId", purpose.getString("contactMechId"))); } catch (GenericEntityException e) { Debug.logError( e, "Trouble getting PostalAddress record for contactMechId: " + purpose.getString("contactMechId"), module); } } return postalAddress; }
public static Map<String, Object> deactivateContact( DispatchContext dctx, Map<String, Object> context) { Delegator delegator = dctx.getDelegator(); LocalDispatcher dispatcher = dctx.getDispatcher(); Security security = dctx.getSecurity(); GenericValue userLogin = (GenericValue) context.get("userLogin"); Locale locale = UtilCommon.getLocale(context); // what contact we're expiring String contactPartyId = (String) context.get("partyId"); // check that userLogin has CRMSFA_CONTACT_DEACTIVATE permission for this contact if (!CrmsfaSecurity.hasPartyRelationSecurity( security, "CRMSFA_CONTACT", "_DEACTIVATE", userLogin, contactPartyId)) { return UtilMessage.createAndLogServiceError("CrmErrorPermissionDenied", locale, MODULE); } // when to expire the contact Timestamp expireDate = (Timestamp) context.get("expireDate"); if (expireDate == null) { expireDate = UtilDateTime.nowTimestamp(); } // in order to deactivate a contact, we expire all party relationships on the expire date try { List<GenericValue> partyRelationships = delegator.findByAnd( "PartyRelationship", UtilMisc.toMap("partyIdFrom", contactPartyId, "roleTypeIdFrom", "CONTACT")); PartyHelper.expirePartyRelationships(partyRelationships, expireDate, dispatcher, userLogin); } catch (GenericEntityException e) { return UtilMessage.createAndLogServiceError( e, "CrmErrorDeactivateContactFail", locale, MODULE); } catch (GenericServiceException e) { return UtilMessage.createAndLogServiceError( e, "CrmErrorDeactivateContactFail", locale, MODULE); } // set the party statusId to PARTY_DISABLED and register the PartyDeactivation try { GenericValue contactParty = delegator.findByPrimaryKey("Party", UtilMisc.toMap("partyId", contactPartyId)); contactParty.put("statusId", "PARTY_DISABLED"); contactParty.store(); delegator.create( "PartyDeactivation", UtilMisc.toMap("partyId", contactPartyId, "deactivationTimestamp", expireDate)); } catch (GenericEntityException e) { return UtilMessage.createAndLogServiceError( e, "CrmErrorDeactivateAccountFail", locale, MODULE); } return ServiceUtil.returnSuccess(); }
/** * Retrieves a single user preference from persistent storage. Call with userPrefTypeId and * optional userPrefLoginId. If userPrefLoginId isn't specified, then the currently logged-in * user's userLoginId will be used. The retrieved preference is contained in the * <b>userPrefMap</b> element. * * @param ctx The DispatchContext that this service is operating in. * @param context Map containing the input arguments. * @return Map with the result of the service, the output parameters. */ public static Map<String, Object> getUserPreference(DispatchContext ctx, Map<String, ?> context) { Locale locale = (Locale) context.get("locale"); if (!PreferenceWorker.isValidGetId(ctx, context)) { return ServiceUtil.returnError( UtilProperties.getMessage(resource, "getPreference.permissionError", locale)); } Delegator delegator = ctx.getDelegator(); String userPrefTypeId = (String) context.get("userPrefTypeId"); if (UtilValidate.isEmpty(userPrefTypeId)) { return ServiceUtil.returnError( UtilProperties.getMessage(resource, "getPreference.invalidArgument", locale)); } String userLoginId = PreferenceWorker.getUserLoginId(context, true); Map<String, String> fieldMap = UtilMisc.toMap("userLoginId", userLoginId, "userPrefTypeId", userPrefTypeId); String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId"); if (UtilValidate.isNotEmpty(userPrefGroupTypeId)) { fieldMap.put("userPrefGroupTypeId", userPrefGroupTypeId); } Map<String, Object> userPrefMap = null; try { GenericValue preference = EntityUtil.getFirst(delegator.findByAnd("UserPreference", fieldMap)); if (preference != null) { userPrefMap = PreferenceWorker.createUserPrefMap(preference); } } catch (GenericEntityException e) { Debug.logWarning(e.getMessage(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "getPreference.readFailure", new Object[] {e.getMessage()}, locale)); } catch (GeneralException e) { Debug.logWarning(e.getMessage(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "getPreference.readFailure", new Object[] {e.getMessage()}, locale)); } Map<String, Object> result = ServiceUtil.returnSuccess(); result.put("userPrefMap", userPrefMap); if (userPrefMap != null) { // Put the value in the result Map too, makes access easier for calling methods. Object userPrefValue = userPrefMap.get(userPrefTypeId); if (userPrefValue != null) { result.put("userPrefValue", userPrefValue); } } return result; }
public static Map<String, Object> reassignContactResponsibleParty( DispatchContext dctx, Map<String, Object> context) { Delegator delegator = dctx.getDelegator(); LocalDispatcher dispatcher = dctx.getDispatcher(); Security security = dctx.getSecurity(); GenericValue userLogin = (GenericValue) context.get("userLogin"); Locale locale = UtilCommon.getLocale(context); String contactPartyId = (String) context.get("contactPartyId"); String newPartyId = (String) context.get("newPartyId"); // ensure reassign permission on this contact if (!CrmsfaSecurity.hasPartyRelationSecurity( security, "CRMSFA_CONTACT", "_REASSIGN", userLogin, contactPartyId)) { return UtilMessage.createAndLogServiceError("CrmErrorPermissionDenied", locale, MODULE); } try { // we need to expire all the active ASSIGNED_TO relationships from the contact party to the // new owner party List<GenericValue> activeAssignedToRelationships = EntityUtil.filterByDate( delegator.findByAnd( "PartyRelationship", UtilMisc.toMap( "partyIdFrom", contactPartyId, "roleTypeIdFrom", "CONTACT", "partyIdTo", newPartyId, "partyRelationshipTypeId", "ASSIGNED_TO"))); PartyHelper.expirePartyRelationships( activeAssignedToRelationships, UtilDateTime.nowTimestamp(), dispatcher, userLogin); // reassign relationship using a helper method boolean result = createResponsibleContactRelationshipForParty( newPartyId, contactPartyId, userLogin, delegator, dispatcher); if (!result) { return UtilMessage.createAndLogServiceError("CrmErrorReassignFail", locale, MODULE); } } catch (GenericServiceException e) { return UtilMessage.createAndLogServiceError(e, "CrmErrorReassignFail", locale, MODULE); } catch (GenericEntityException e) { return UtilMessage.createAndLogServiceError(e, "CrmErrorReassignFail", locale, MODULE); } return ServiceUtil.returnSuccess(); }
/** Checks if the given party with role is unassigned. */ public static boolean isUnassigned(Delegator delegator, String partyId, String roleTypeId) throws GenericEntityException { List<GenericValue> activeRelationships = EntityUtil.filterByDate( delegator.findByAnd( "PartyRelationship", UtilMisc.toMap( "partyIdFrom", partyId, "roleTypeIdFrom", roleTypeId, "partyRelationshipTypeId", "ASSIGNED_TO"))); return activeRelationships.size() == 0; }
public static GenericValue findPartyLatestUserLogin(String partyId, Delegator delegator) { try { List<GenericValue> userLoginList = delegator.findByAnd( "UserLogin", UtilMisc.toMap("partyId", partyId), UtilMisc.toList("-" + ModelEntity.STAMP_FIELD)); return EntityUtil.getFirst(userLoginList); } catch (GenericEntityException e) { Debug.logError( e, "Error while finding latest UserLogin for party with ID [" + partyId + "]: " + e.toString(), module); return null; } }
public static Timestamp findPartyLastLoginTime(String partyId, Delegator delegator) { try { List<GenericValue> loginHistory = delegator.findByAnd( "UserLoginHistory", UtilMisc.toMap("partyId", partyId), UtilMisc.toList("-fromDate")); GenericValue v = EntityUtil.getFirst(loginHistory); if (v != null) { return v.getTimestamp("fromDate"); } else { return null; } } catch (GenericEntityException e) { Debug.logError( e, "Error while finding latest login time for party with ID [" + partyId + "]: " + e.toString(), module); return null; } }
public static GenericValue findPartyLatestContactMech( String partyId, String contactMechTypeId, Delegator delegator) { try { List<GenericValue> cmList = delegator.findByAnd( "PartyAndContactMech", UtilMisc.toMap("partyId", partyId, "contactMechTypeId", contactMechTypeId), UtilMisc.toList("-fromDate")); cmList = EntityUtil.filterByDate(cmList); return EntityUtil.getFirst(cmList); } catch (GenericEntityException e) { Debug.logError( e, "Error while finding latest ContactMech for party with ID [" + partyId + "] TYPE [" + contactMechTypeId + "]: " + e.toString(), module); return null; } }
public static Map<String, Object> removeContactFromAccount( DispatchContext dctx, Map<String, Object> context) { Delegator delegator = dctx.getDelegator(); LocalDispatcher dispatcher = dctx.getDispatcher(); Security security = dctx.getSecurity(); GenericValue userLogin = (GenericValue) context.get("userLogin"); Locale locale = UtilCommon.getLocale(context); String contactPartyId = (String) context.get("contactPartyId"); String accountPartyId = (String) context.get("accountPartyId"); // ensure update permission on account if (!CrmsfaSecurity.hasPartyRelationSecurity( security, "CRMSFA_ACCOUNT", "_UPDATE", userLogin, accountPartyId)) { return UtilMessage.createAndLogServiceError("CrmErrorPermissionDenied", locale, MODULE); } try { // find and expire all contact relationships between the contact and account List<GenericValue> relations = delegator.findByAnd( "PartyRelationship", UtilMisc.toMap( "partyIdTo", accountPartyId, "partyIdFrom", contactPartyId, "partyRelationshipTypeId", PartyRelationshipTypeConstants.CONTACT_REL_INV)); PartyHelper.expirePartyRelationships( relations, UtilDateTime.nowTimestamp(), dispatcher, userLogin); } catch (GenericServiceException e) { return UtilMessage.createAndLogServiceError(e, "CrmErrorRemoveContactFail", locale, MODULE); } catch (GenericEntityException e) { return UtilMessage.createAndLogServiceError(e, "CrmErrorRemoveContactFail", locale, MODULE); } return ServiceUtil.returnSuccess(); }
public static boolean isProductInCategory( Delegator delegator, String productId, String productCategoryId) throws GenericEntityException { if (productCategoryId == null) return false; if (UtilValidate.isEmpty(productId)) return false; List<GenericValue> productCategoryMembers = EntityUtil.filterByDate( delegator.findByAnd( "ProductCategoryMember", UtilMisc.toMap("productCategoryId", productCategoryId, "productId", productId), null, true), true); if (UtilValidate.isEmpty(productCategoryMembers)) { // before giving up see if this is a variant product, and if so look up the virtual product // and check it... GenericValue product = delegator.findOne("Product", UtilMisc.toMap("productId", productId), true); List<GenericValue> productAssocs = ProductWorker.getVariantVirtualAssocs(product); // this does take into account that a product could be a variant of multiple products, but // this shouldn't ever really happen... if (productAssocs != null) { for (GenericValue productAssoc : productAssocs) { if (isProductInCategory( delegator, productAssoc.getString("productId"), productCategoryId)) { return true; } } } return false; } else { return true; } }
public static Map<String, Object> assembleCrmsfaShipmentFormMergeContext( Delegator delegator, String orderId, String shipGroupSeqId, String shipmentId, Locale locale) { Map<String, Object> templateContext = new HashMap<String, Object>(); try { // Prefer shipment data if shipmentId is provided if (UtilValidate.isNotEmpty(shipmentId)) { GenericValue shipment = delegator.findByPrimaryKey("Shipment", UtilMisc.toMap("shipmentId", shipmentId)); if (UtilValidate.isNotEmpty(shipment)) { GenericValue shipLoc = shipment.getRelatedOne("DestinationPostalAddress"); if (UtilValidate.isNotEmpty(shipLoc)) { templateContext.put("orderShippingAddress1", shipLoc.get("address1")); templateContext.put("orderShippingAddress2", shipLoc.get("address2")); templateContext.put("orderShippingCity", shipLoc.get("city")); templateContext.put("orderShippingPostalCode", shipLoc.get("postalCode")); GenericValue stateProvGeo = shipLoc.getRelatedOne("StateProvinceGeo"); if (UtilValidate.isNotEmpty(stateProvGeo)) { templateContext.put("orderShippingStateProvince", stateProvGeo.get("geoName")); } GenericValue countryGeo = shipLoc.getRelatedOne("CountryGeo"); if (UtilValidate.isNotEmpty(countryGeo)) { templateContext.put("orderShippingCountry", countryGeo.get("geoName")); } } GenericValue phoneNumber = shipment.getRelatedOne("DestinationTelecomNumber"); if (UtilValidate.isNotEmpty(phoneNumber)) { String phoneNumberString = UtilValidate.isEmpty(phoneNumber.getString("countryCode")) ? "" : phoneNumber.getString("countryCode") + " "; if (UtilValidate.isNotEmpty(phoneNumber.getString("areaCode"))) { phoneNumberString += phoneNumber.getString("areaCode") + " "; } if (UtilValidate.isNotEmpty(phoneNumber.getString("contactNumber"))) { phoneNumberString += phoneNumber.getString("contactNumber"); } templateContext.put("orderShippingPhone", phoneNumberString); } GenericValue statusItem = shipment.getRelatedOne("StatusItem"); if (UtilValidate.isNotEmpty(statusItem)) { templateContext.put("shipmentStatus", statusItem.get("description", locale)); } } } else if (UtilValidate.isNotEmpty(orderId)) { OrderReadHelper orh = new OrderReadHelper(delegator, orderId); GenericValue shipGroup = orh.getOrderItemShipGroup(shipGroupSeqId); if (UtilValidate.isEmpty(shipGroup)) { // Default to the first ship group if no shipGroupSeqId is provided List shipGroups = orh.getOrderItemShipGroups(); if (UtilValidate.isNotEmpty(shipGroups)) { shipGroup = (GenericValue) shipGroups.get(0); } } if (UtilValidate.isNotEmpty(shipGroup)) { GenericValue shipLoc = shipGroup.getRelatedOne("PostalAddress"); if (UtilValidate.isNotEmpty(shipLoc)) { templateContext.put("orderShippingAddress1", shipLoc.get("address1")); templateContext.put("orderShippingAddress2", shipLoc.get("address2")); templateContext.put("orderShippingCity", shipLoc.get("city")); templateContext.put("orderShippingPostalCode", shipLoc.get("postalCode")); GenericValue stateProvGeo = shipLoc.getRelatedOne("StateProvinceGeo"); if (UtilValidate.isNotEmpty(stateProvGeo)) { templateContext.put("orderShippingStateProvince", stateProvGeo.get("geoName")); } GenericValue countryGeo = shipLoc.getRelatedOne("CountryGeo"); if (UtilValidate.isNotEmpty(countryGeo)) { templateContext.put("orderShippingCountry", countryGeo.get("geoName")); } } GenericValue phoneNumber = shipGroup.getRelatedOne("TelecomTelecomNumber"); if (UtilValidate.isNotEmpty(phoneNumber)) { String phoneNumberString = UtilValidate.isEmpty(phoneNumber.getString("countryCode")) ? "" : phoneNumber.getString("countryCode") + " "; if (UtilValidate.isNotEmpty(phoneNumber.getString("areaCode"))) { phoneNumberString += phoneNumber.getString("areaCode") + " "; } if (UtilValidate.isNotEmpty(phoneNumber.getString("contactNumber"))) { phoneNumberString += phoneNumber.getString("contactNumber"); } templateContext.put("orderShippingPhone", phoneNumberString); } // Find any shipments relating to this ship group List<GenericValue> shipments = delegator.findByAnd( "Shipment", UtilMisc.toMap( "primaryOrderId", orderId, "primaryShipGroupSeqId", shipGroup.getString("shipGroupSeqId")), UtilMisc.toList("createdStamp DESC")); GenericValue shipment = EntityUtil.getFirst(shipments); if (UtilValidate.isNotEmpty(shipment)) { GenericValue statusItem = shipment.getRelatedOne("StatusItem"); if (UtilValidate.isNotEmpty(statusItem)) { templateContext.put("shipmentStatus", statusItem.get("description", locale)); } } } } } catch (GenericEntityException e) { Debug.logError(e, MODULE); } return templateContext; }
private static List<GenericValue> getTaxAdjustments( Delegator delegator, GenericValue product, GenericValue productStore, String payToPartyId, String billToPartyId, Set<GenericValue> taxAuthoritySet, BigDecimal itemPrice, BigDecimal itemQuantity, BigDecimal itemAmount, BigDecimal shippingAmount, BigDecimal orderPromotionsAmount) { Timestamp nowTimestamp = UtilDateTime.nowTimestamp(); List<GenericValue> adjustments = FastList.newInstance(); if (payToPartyId == null) { if (productStore != null) { payToPartyId = productStore.getString("payToPartyId"); } } // store expr EntityCondition storeCond = null; if (productStore != null) { storeCond = EntityCondition.makeCondition( EntityCondition.makeCondition( "productStoreId", EntityOperator.EQUALS, productStore.get("productStoreId")), EntityOperator.OR, EntityCondition.makeCondition("productStoreId", EntityOperator.EQUALS, null)); } else { storeCond = EntityCondition.makeCondition("productStoreId", EntityOperator.EQUALS, null); } // build the TaxAuthority expressions (taxAuthGeoId, taxAuthPartyId) List<EntityCondition> taxAuthCondOrList = FastList.newInstance(); // start with the _NA_ TaxAuthority... taxAuthCondOrList.add( EntityCondition.makeCondition( EntityCondition.makeCondition("taxAuthPartyId", EntityOperator.EQUALS, "_NA_"), EntityOperator.AND, EntityCondition.makeCondition("taxAuthGeoId", EntityOperator.EQUALS, "_NA_"))); for (GenericValue taxAuthority : taxAuthoritySet) { EntityCondition taxAuthCond = EntityCondition.makeCondition( EntityCondition.makeCondition( "taxAuthPartyId", EntityOperator.EQUALS, taxAuthority.getString("taxAuthPartyId")), EntityOperator.AND, EntityCondition.makeCondition( "taxAuthGeoId", EntityOperator.EQUALS, taxAuthority.getString("taxAuthGeoId"))); taxAuthCondOrList.add(taxAuthCond); } EntityCondition taxAuthoritiesCond = EntityCondition.makeCondition(taxAuthCondOrList, EntityOperator.OR); try { EntityCondition productCategoryCond = null; if (product != null) { // find the tax categories associated with the product and filter by those, with an IN // clause or some such // if this product is variant, find the virtual product id and consider also the categories // of the virtual // question: get all categories, or just a special type? for now let's do all categories... String virtualProductId = null; if ("Y".equals(product.getString("isVariant"))) { virtualProductId = ProductWorker.getVariantVirtualId(product); } Set<String> productCategoryIdSet = FastSet.newInstance(); EntityCondition productIdCond = null; if (virtualProductId != null) { productIdCond = EntityCondition.makeCondition( EntityCondition.makeCondition( "productId", EntityOperator.EQUALS, product.getString("productId")), EntityOperator.OR, EntityCondition.makeCondition( "productId", EntityOperator.EQUALS, virtualProductId)); } else { productIdCond = EntityCondition.makeCondition( "productId", EntityOperator.EQUALS, product.getString("productId")); } List<GenericValue> pcmList = delegator.findList( "ProductCategoryMember", productIdCond, UtilMisc.toSet("productCategoryId", "fromDate", "thruDate"), null, null, true); pcmList = EntityUtil.filterByDate(pcmList, true); for (GenericValue pcm : pcmList) { productCategoryIdSet.add(pcm.getString("productCategoryId")); } if (productCategoryIdSet.size() == 0) { productCategoryCond = EntityCondition.makeCondition("productCategoryId", EntityOperator.EQUALS, null); } else { productCategoryCond = EntityCondition.makeCondition( EntityCondition.makeCondition("productCategoryId", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition( "productCategoryId", EntityOperator.IN, productCategoryIdSet)); } } else { productCategoryCond = EntityCondition.makeCondition("productCategoryId", EntityOperator.EQUALS, null); } // FIXME handles shipping and promo tax. Simple solution, see // https://issues.apache.org/jira/browse/OFBIZ-4160 for a better one if (product == null && shippingAmount != null) { EntityCondition taxShippingCond = EntityCondition.makeCondition( EntityCondition.makeCondition("taxShipping", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition("taxShipping", EntityOperator.EQUALS, "Y")); if (productCategoryCond != null) { productCategoryCond = EntityCondition.makeCondition( productCategoryCond, EntityOperator.OR, taxShippingCond); } } if (product == null && orderPromotionsAmount != null) { EntityCondition taxOrderPromotionsCond = EntityCondition.makeCondition( EntityCondition.makeCondition("taxPromotions", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition("taxPromotions", EntityOperator.EQUALS, "Y")); if (productCategoryCond != null) { productCategoryCond = EntityCondition.makeCondition( productCategoryCond, EntityOperator.OR, taxOrderPromotionsCond); } } // build the main condition clause List<EntityCondition> mainExprs = UtilMisc.toList(storeCond, taxAuthoritiesCond, productCategoryCond); mainExprs.add( EntityCondition.makeCondition( EntityCondition.makeCondition("minItemPrice", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition( "minItemPrice", EntityOperator.LESS_THAN_EQUAL_TO, itemPrice))); mainExprs.add( EntityCondition.makeCondition( EntityCondition.makeCondition("minPurchase", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition( "minPurchase", EntityOperator.LESS_THAN_EQUAL_TO, itemAmount))); EntityCondition mainCondition = EntityCondition.makeCondition(mainExprs, EntityOperator.AND); // create the orderby clause List<String> orderList = UtilMisc.<String>toList("minItemPrice", "minPurchase", "fromDate"); // finally ready... do the rate query List<GenericValue> lookupList = delegator.findList( "TaxAuthorityRateProduct", mainCondition, null, orderList, null, false); List<GenericValue> filteredList = EntityUtil.filterByDate(lookupList, true); if (filteredList.size() == 0) { Debug.logWarning( "In TaxAuthority Product Rate no records were found for condition:" + mainCondition.toString(), module); return adjustments; } // find the right entry(s) based on purchase amount for (GenericValue taxAuthorityRateProduct : filteredList) { BigDecimal taxRate = taxAuthorityRateProduct.get("taxPercentage") != null ? taxAuthorityRateProduct.getBigDecimal("taxPercentage") : ZERO_BASE; BigDecimal taxable = ZERO_BASE; if (product != null && (product.get("taxable") == null || (product.get("taxable") != null && product.getBoolean("taxable").booleanValue()))) { taxable = taxable.add(itemAmount); } if (shippingAmount != null && taxAuthorityRateProduct != null && (taxAuthorityRateProduct.get("taxShipping") == null || (taxAuthorityRateProduct.get("taxShipping") != null && taxAuthorityRateProduct.getBoolean("taxShipping").booleanValue()))) { taxable = taxable.add(shippingAmount); } if (orderPromotionsAmount != null && taxAuthorityRateProduct != null && (taxAuthorityRateProduct.get("taxPromotions") == null || (taxAuthorityRateProduct.get("taxPromotions") != null && taxAuthorityRateProduct.getBoolean("taxPromotions").booleanValue()))) { taxable = taxable.add(orderPromotionsAmount); } if (taxable.compareTo(BigDecimal.ZERO) == 0) { // this should make it less confusing if the taxable flag on the product is not Y/true, // and there is no shipping and such continue; } // taxRate is in percentage, so needs to be divided by 100 BigDecimal taxAmount = (taxable.multiply(taxRate)) .divide(PERCENT_SCALE, salestaxCalcDecimals, salestaxRounding); String taxAuthGeoId = taxAuthorityRateProduct.getString("taxAuthGeoId"); String taxAuthPartyId = taxAuthorityRateProduct.getString("taxAuthPartyId"); // get glAccountId from TaxAuthorityGlAccount entity using the payToPartyId as the // organizationPartyId GenericValue taxAuthorityGlAccount = delegator.findByPrimaryKey( "TaxAuthorityGlAccount", UtilMisc.toMap( "taxAuthPartyId", taxAuthPartyId, "taxAuthGeoId", taxAuthGeoId, "organizationPartyId", payToPartyId)); String taxAuthGlAccountId = null; if (taxAuthorityGlAccount != null) { taxAuthGlAccountId = taxAuthorityGlAccount.getString("glAccountId"); } else { // TODO: what to do if no TaxAuthorityGlAccount found? Use some default, or is that done // elsewhere later on? } GenericValue productPrice = null; if (product != null && taxAuthPartyId != null && taxAuthGeoId != null) { // find a ProductPrice for the productId and taxAuth* valxues, and see if it has a // priceWithTax value Map<String, String> priceFindMap = UtilMisc.toMap( "productId", product.getString("productId"), "taxAuthPartyId", taxAuthPartyId, "taxAuthGeoId", taxAuthGeoId, "productPricePurposeId", "PURCHASE"); List<GenericValue> productPriceList = delegator.findByAnd("ProductPrice", priceFindMap, UtilMisc.toList("-fromDate")); productPriceList = EntityUtil.filterByDate(productPriceList, true); productPrice = (productPriceList != null && productPriceList.size() > 0) ? productPriceList.get(0) : null; // Debug.logInfo("=================== productId=" + product.getString("productId"), // module); // Debug.logInfo("=================== productPrice=" + productPrice, module); } GenericValue taxAdjValue = delegator.makeValue("OrderAdjustment"); if (productPrice != null && "Y".equals(productPrice.getString("taxInPrice"))) { // tax is in the price already, so we want the adjustment to be a VAT_TAX adjustment to be // subtracted instead of a SALES_TAX adjustment to be added taxAdjValue.set("orderAdjustmentTypeId", "VAT_TAX"); // the amount will be different because we want to figure out how much of the price was // tax, and not how much tax needs to be added // the formula is: taxAmount = priceWithTax - (priceWithTax/(1+taxPercentage/100)) BigDecimal taxAmountIncluded = itemAmount.subtract( itemAmount.divide( BigDecimal.ONE.add( taxRate.divide(PERCENT_SCALE, 4, BigDecimal.ROUND_HALF_UP)), 3, BigDecimal.ROUND_HALF_UP)); taxAdjValue.set("amountAlreadyIncluded", taxAmountIncluded); taxAdjValue.set("amount", BigDecimal.ZERO); } else { taxAdjValue.set("orderAdjustmentTypeId", "SALES_TAX"); taxAdjValue.set("amount", taxAmount); } taxAdjValue.set("sourcePercentage", taxRate); taxAdjValue.set( "taxAuthorityRateSeqId", taxAuthorityRateProduct.getString("taxAuthorityRateSeqId")); // the primary Geo should be the main jurisdiction that the tax is for, and the secondary // would just be to define a parent or wrapping jurisdiction of the primary taxAdjValue.set("primaryGeoId", taxAuthGeoId); taxAdjValue.set("comments", taxAuthorityRateProduct.getString("description")); if (taxAuthPartyId != null) taxAdjValue.set("taxAuthPartyId", taxAuthPartyId); if (taxAuthGlAccountId != null) taxAdjValue.set("overrideGlAccountId", taxAuthGlAccountId); if (taxAuthGeoId != null) taxAdjValue.set("taxAuthGeoId", taxAuthGeoId); // check to see if this party has a tax ID for this, and if the party is tax exempt in the // primary (most-local) jurisdiction if (UtilValidate.isNotEmpty(billToPartyId) && UtilValidate.isNotEmpty(taxAuthGeoId)) { // see if partyId is a member of any groups, if so honor their tax exemptions // look for PartyRelationship with partyRelationshipTypeId=GROUP_ROLLUP, the partyIdTo is // the group member, so the partyIdFrom is the groupPartyId Set<String> billToPartyIdSet = FastSet.newInstance(); billToPartyIdSet.add(billToPartyId); List<GenericValue> partyRelationshipList = EntityUtil.filterByDate( delegator.findByAndCache( "PartyRelationship", UtilMisc.toMap( "partyIdTo", billToPartyId, "partyRelationshipTypeId", "GROUP_ROLLUP")), true); for (GenericValue partyRelationship : partyRelationshipList) { billToPartyIdSet.add(partyRelationship.getString("partyIdFrom")); } handlePartyTaxExempt( taxAdjValue, billToPartyIdSet, taxAuthGeoId, taxAuthPartyId, taxAmount, nowTimestamp, delegator); } else { Debug.logInfo( "NOTE: A tax calculation was done without a billToPartyId or taxAuthGeoId, so no tax exemptions or tax IDs considered; billToPartyId=[" + billToPartyId + "] taxAuthGeoId=[" + taxAuthGeoId + "]", module); } adjustments.add(taxAdjValue); if (productPrice != null && itemQuantity != null && productPrice.getBigDecimal("priceWithTax") != null && !"Y".equals(productPrice.getString("taxInPrice"))) { BigDecimal priceWithTax = productPrice.getBigDecimal("priceWithTax"); BigDecimal price = productPrice.getBigDecimal("price"); BigDecimal baseSubtotal = price.multiply(itemQuantity); BigDecimal baseTaxAmount = (baseSubtotal.multiply(taxRate)) .divide(PERCENT_SCALE, salestaxCalcDecimals, salestaxRounding); // Debug.logInfo("=================== priceWithTax=" + priceWithTax, module); // Debug.logInfo("=================== enteredTotalPriceWithTax=" + // enteredTotalPriceWithTax, module); // Debug.logInfo("=================== calcedTotalPriceWithTax=" + calcedTotalPriceWithTax, // module); // tax is not already in price so we want to add it in, but this is a VAT situation so // adjust to make it as accurate as possible // for VAT taxes if the calculated total item price plus calculated taxes is different // from what would be // expected based on the original entered price with taxes (if the price was entered this // way), then create // an adjustment that corrects for the difference, and this correction will be effectively // subtracted from the // price and not from the tax (the tax is meant to be calculated based on Tax Authority // rules and so should // not be shorted) // TODO (don't think this is needed, but just to keep it in mind): get this to work with // multiple VAT tax authorities instead of just one (right now will get incorrect totals // if there are multiple taxes included in the price) // TODO add constraint to ProductPrice lookup by any productStoreGroupId associated with // the current productStore BigDecimal enteredTotalPriceWithTax = priceWithTax.multiply(itemQuantity); BigDecimal calcedTotalPriceWithTax = (baseSubtotal).add(baseTaxAmount); if (!enteredTotalPriceWithTax.equals(calcedTotalPriceWithTax)) { // if the calced amount is higher than the entered amount we want the value to be // negative // to get it down to match the entered amount // so, subtract the calced amount from the entered amount (ie: correction = entered - // calced) BigDecimal correctionAmount = enteredTotalPriceWithTax.subtract(calcedTotalPriceWithTax); // Debug.logInfo("=================== correctionAmount=" + correctionAmount, module); GenericValue correctionAdjValue = delegator.makeValue("OrderAdjustment"); correctionAdjValue.set( "taxAuthorityRateSeqId", taxAuthorityRateProduct.getString("taxAuthorityRateSeqId")); correctionAdjValue.set("amount", correctionAmount); // don't set this, causes a doubling of the tax rate because calling code adds up all // tax rates: correctionAdjValue.set("sourcePercentage", taxRate); correctionAdjValue.set("orderAdjustmentTypeId", "VAT_PRICE_CORRECT"); // the primary Geo should be the main jurisdiction that the tax is for, and the // secondary would just be to define a parent or wrapping jurisdiction of the primary correctionAdjValue.set("primaryGeoId", taxAuthGeoId); correctionAdjValue.set("comments", taxAuthorityRateProduct.getString("description")); if (taxAuthPartyId != null) correctionAdjValue.set("taxAuthPartyId", taxAuthPartyId); if (taxAuthGlAccountId != null) correctionAdjValue.set("overrideGlAccountId", taxAuthGlAccountId); if (taxAuthGeoId != null) correctionAdjValue.set("taxAuthGeoId", taxAuthGeoId); adjustments.add(correctionAdjValue); } } } } catch (GenericEntityException e) { Debug.logError(e, "Problems looking up tax rates", module); return FastList.newInstance(); } return adjustments; }
public static void indexKeywords(GenericValue product, boolean doAll) throws GenericEntityException { if (product == null) return; Timestamp nowTimestamp = UtilDateTime.nowTimestamp(); if (!doAll) { if ("N".equals(product.getString("autoCreateKeywords"))) { return; } if ("Y".equals(product.getString("isVariant")) && "true" .equals(UtilProperties.getPropertyValue("prodsearch", "index.ignore.variants"))) { return; } Timestamp salesDiscontinuationDate = product.getTimestamp("salesDiscontinuationDate"); if (salesDiscontinuationDate != null && salesDiscontinuationDate.before(nowTimestamp) && "true" .equals( UtilProperties.getPropertyValue( "prodsearch", "index.ignore.discontinued.sales"))) { return; } } Delegator delegator = product.getDelegator(); if (delegator == null) return; String productId = product.getString("productId"); // get these in advance just once since they will be used many times for the multiple strings to // index String separators = KeywordSearchUtil.getSeparators(); String stopWordBagOr = KeywordSearchUtil.getStopWordBagOr(); String stopWordBagAnd = KeywordSearchUtil.getStopWordBagAnd(); boolean removeStems = KeywordSearchUtil.getRemoveStems(); Set<String> stemSet = KeywordSearchUtil.getStemSet(); Map<String, Long> keywords = new TreeMap<String, Long>(); List<String> strings = FastList.newInstance(); int pidWeight = 1; try { pidWeight = Integer.parseInt( UtilProperties.getPropertyValue("prodsearch", "index.weight.Product.productId", "0")); } catch (Exception e) { Debug.logWarning("Could not parse weight number: " + e.toString(), module); } keywords.put(product.getString("productId").toLowerCase(), Long.valueOf(pidWeight)); // Product fields - default is 0 if not found in the properties file if (!"0" .equals( UtilProperties.getPropertyValue( "prodsearch", "index.weight.Product.productName", "0"))) { addWeightedKeywordSourceString(product, "productName", strings); } if (!"0" .equals( UtilProperties.getPropertyValue( "prodsearch", "index.weight.Product.internalName", "0"))) { addWeightedKeywordSourceString(product, "internalName", strings); } if (!"0" .equals( UtilProperties.getPropertyValue("prodsearch", "index.weight.Product.brandName", "0"))) { addWeightedKeywordSourceString(product, "brandName", strings); } if (!"0" .equals( UtilProperties.getPropertyValue( "prodsearch", "index.weight.Product.description", "0"))) { addWeightedKeywordSourceString(product, "description", strings); } if (!"0" .equals( UtilProperties.getPropertyValue( "prodsearch", "index.weight.Product.longDescription", "0"))) { addWeightedKeywordSourceString(product, "longDescription", strings); } // ProductFeatureAppl if (!"0" .equals( UtilProperties.getPropertyValue( "prodsearch", "index.weight.ProductFeatureAndAppl.description", "0")) || !"0" .equals( UtilProperties.getPropertyValue( "prodsearch", "index.weight.ProductFeatureAndAppl.abbrev", "0")) || !"0" .equals( UtilProperties.getPropertyValue( "prodsearch", "index.weight.ProductFeatureAndAppl.idCode", "0"))) { // get strings from attributes and features List<GenericValue> productFeatureAndAppls = delegator.findByAnd("ProductFeatureAndAppl", UtilMisc.toMap("productId", productId)); for (GenericValue productFeatureAndAppl : productFeatureAndAppls) { addWeightedKeywordSourceString(productFeatureAndAppl, "description", strings); addWeightedKeywordSourceString(productFeatureAndAppl, "abbrev", strings); addWeightedKeywordSourceString(productFeatureAndAppl, "idCode", strings); } } // ProductAttribute if (!"0" .equals( UtilProperties.getPropertyValue( "prodsearch", "index.weight.ProductAttribute.attrName", "0")) || !"0" .equals( UtilProperties.getPropertyValue( "prodsearch", "index.weight.ProductAttribute.attrValue", "0"))) { List<GenericValue> productAttributes = delegator.findByAnd("ProductAttribute", UtilMisc.toMap("productId", productId)); for (GenericValue productAttribute : productAttributes) { addWeightedKeywordSourceString(productAttribute, "attrName", strings); addWeightedKeywordSourceString(productAttribute, "attrValue", strings); } } // GoodIdentification if (!"0" .equals( UtilProperties.getPropertyValue( "prodsearch", "index.weight.GoodIdentification.idValue", "0"))) { List<GenericValue> goodIdentifications = delegator.findByAnd("GoodIdentification", UtilMisc.toMap("productId", productId)); for (GenericValue goodIdentification : goodIdentifications) { addWeightedKeywordSourceString(goodIdentification, "idValue", strings); } } // Variant Product IDs if ("Y".equals(product.getString("isVirtual"))) { if (!"0" .equals( UtilProperties.getPropertyValue( "prodsearch", "index.weight.Variant.Product.productId", "0"))) { List<GenericValue> variantProductAssocs = delegator.findByAnd( "ProductAssoc", UtilMisc.toMap("productId", productId, "productAssocTypeId", "PRODUCT_VARIANT")); variantProductAssocs = EntityUtil.filterByDate(variantProductAssocs); for (GenericValue variantProductAssoc : variantProductAssocs) { int weight = 1; try { weight = Integer.parseInt( UtilProperties.getPropertyValue( "prodsearch", "index.weight.Variant.Product.productId", "0")); } catch (Exception e) { Debug.logWarning("Could not parse weight number: " + e.toString(), module); } for (int i = 0; i < weight; i++) { strings.add(variantProductAssoc.getString("productIdTo")); } } } } String productContentTypes = UtilProperties.getPropertyValue("prodsearch", "index.include.ProductContentTypes"); for (String productContentTypeId : productContentTypes.split(",")) { int weight = 1; try { // this is defaulting to a weight of 1 because you specified you wanted to index this type weight = Integer.parseInt( UtilProperties.getPropertyValue( "prodsearch", "index.weight.ProductContent." + productContentTypeId, "1")); } catch (Exception e) { Debug.logWarning("Could not parse weight number: " + e.toString(), module); } List<GenericValue> productContentAndInfos = delegator.findByAnd( "ProductContentAndInfo", UtilMisc.toMap("productId", productId, "productContentTypeId", productContentTypeId), null); for (GenericValue productContentAndInfo : productContentAndInfos) { addWeightedDataResourceString(productContentAndInfo, weight, strings, delegator, product); List<GenericValue> alternateViews = productContentAndInfo.getRelated( "ContentAssocDataResourceViewTo", UtilMisc.toMap("caContentAssocTypeId", "ALTERNATE_LOCALE"), UtilMisc.toList("-caFromDate")); alternateViews = EntityUtil.filterByDate( alternateViews, UtilDateTime.nowTimestamp(), "caFromDate", "caThruDate", true); for (GenericValue thisView : alternateViews) { addWeightedDataResourceString(thisView, weight, strings, delegator, product); } } } if (UtilValidate.isNotEmpty(strings)) { for (String str : strings) { // call process keywords method here KeywordSearchUtil.processKeywordsForIndex( str, keywords, separators, stopWordBagAnd, stopWordBagOr, removeStems, stemSet); } } List<GenericValue> toBeStored = FastList.newInstance(); int keywordMaxLength = Integer.parseInt( UtilProperties.getPropertyValue("prodsearch", "product.keyword.max.length")); for (Map.Entry<String, Long> entry : keywords.entrySet()) { if (entry.getKey().length() <= keywordMaxLength) { GenericValue productKeyword = delegator.makeValue( "ProductKeyword", UtilMisc.toMap( "productId", product.getString("productId"), "keyword", entry.getKey(), "keywordTypeId", "KWT_KEYWORD", "relevancyWeight", entry.getValue())); toBeStored.add(productKeyword); } } if (toBeStored.size() > 0) { if (Debug.verboseOn()) Debug.logVerbose( "[KeywordIndex.indexKeywords] Storing " + toBeStored.size() + " keywords for productId " + product.getString("productId"), module); if ("true" .equals( UtilProperties.getPropertyValue("prodsearch", "index.delete.on_index", "false"))) { // delete all keywords if the properties file says to delegator.removeByAnd( "ProductKeyword", UtilMisc.toMap("productId", product.getString("productId"))); } delegator.storeAll(toBeStored); } }
public static List<GenericValue> getRelatedCategoriesRet( Delegator delegator, String attributeName, String parentId, boolean limitView, boolean excludeEmpty, boolean recursive) { List<GenericValue> categories = FastList.newInstance(); if (Debug.verboseOn()) Debug.logVerbose("[CategoryWorker.getRelatedCategories] ParentID: " + parentId, module); List<GenericValue> rollups = null; try { rollups = delegator.findByAnd( "ProductCategoryRollup", UtilMisc.toMap("parentProductCategoryId", parentId), UtilMisc.toList("sequenceNum"), true); if (limitView) { rollups = EntityUtil.filterByDate(rollups, true); } } catch (GenericEntityException e) { Debug.logWarning(e.getMessage(), module); } if (rollups != null) { // Debug.logInfo("Rollup size: " + rollups.size(), module); for (GenericValue parent : rollups) { // Debug.logInfo("Adding child of: " + parent.getString("parentProductCategoryId"), module); GenericValue cv = null; try { cv = parent.getRelatedOne("CurrentProductCategory", true); } catch (GenericEntityException e) { Debug.logWarning(e.getMessage(), module); } if (cv != null) { if (excludeEmpty) { if (!isCategoryEmpty(cv)) { // Debug.logInfo("Child : " + cv.getString("productCategoryId") + " is not empty.", // module); categories.add(cv); if (recursive) { categories.addAll( getRelatedCategoriesRet( delegator, attributeName, cv.getString("productCategoryId"), limitView, excludeEmpty, recursive)); } } } else { categories.add(cv); if (recursive) { categories.addAll( getRelatedCategoriesRet( delegator, attributeName, cv.getString("productCategoryId"), limitView, excludeEmpty, recursive)); } } } } } return categories; }
/** * Creates and updates a PartyRelationship creating related PartyRoles if needed. A side of the * relationship is checked to maintain history * * @param ctx The DispatchContext that this service is operating in * @param context Map containing the input parameters * @return Map with the result of the service, the output parameters */ public static Map<String, Object> createUpdatePartyRelationshipAndRoles( DispatchContext ctx, Map<String, ? extends Object> context) { Map<String, Object> result = FastMap.newInstance(); Delegator delegator = ctx.getDelegator(); LocalDispatcher dispatcher = ctx.getDispatcher(); try { List<GenericValue> partyRelationShipList = PartyRelationshipHelper.getActivePartyRelationships(delegator, context); if (UtilValidate.isEmpty( partyRelationShipList)) { // If already exists and active nothing to do: keep the current // one String partyId = (String) context.get("partyId"); String partyIdFrom = (String) context.get("partyIdFrom"); String partyIdTo = (String) context.get("partyIdTo"); String roleTypeIdFrom = (String) context.get("roleTypeIdFrom"); String roleTypeIdTo = (String) context.get("roleTypeIdTo"); String partyRelationshipTypeId = (String) context.get("partyRelationshipTypeId"); // Before creating the partyRelationShip, create the partyRoles if they don't exist GenericValue partyToRole = null; partyToRole = delegator.findOne( "PartyRole", UtilMisc.toMap("partyId", partyIdTo, "roleTypeId", roleTypeIdTo), false); if (partyToRole == null) { partyToRole = delegator.makeValue( "PartyRole", UtilMisc.toMap("partyId", partyIdTo, "roleTypeId", roleTypeIdTo)); partyToRole.create(); } GenericValue partyFromRole = null; partyFromRole = delegator.findOne( "PartyRole", UtilMisc.toMap("partyId", partyIdFrom, "roleTypeId", roleTypeIdFrom), false); if (partyFromRole == null) { partyFromRole = delegator.makeValue( "PartyRole", UtilMisc.toMap("partyId", partyIdFrom, "roleTypeId", roleTypeIdFrom)); partyFromRole.create(); } // Check if there is already a partyRelationship of that type with another party from the // side indicated String sideChecked = partyIdFrom.equals(partyId) ? "partyIdFrom" : "partyIdTo"; partyRelationShipList = delegator.findByAnd( "PartyRelationship", UtilMisc.toMap( sideChecked, partyId, "roleTypeIdFrom", roleTypeIdFrom, "roleTypeIdTo", roleTypeIdTo, "partyRelationshipTypeId", partyRelationshipTypeId)); // We consider the last one (in time) as sole active (we try to maintain a unique // relationship and keep changes history) partyRelationShipList = EntityUtil.filterByDate(partyRelationShipList); GenericValue oldPartyRelationShip = EntityUtil.getFirst(partyRelationShipList); if (UtilValidate.isNotEmpty(oldPartyRelationShip)) { oldPartyRelationShip.setFields( UtilMisc.toMap("thruDate", UtilDateTime.nowTimestamp())); // Current becomes inactive oldPartyRelationShip.store(); } try { dispatcher.runSync("createPartyRelationship", context); // Create new one } catch (GenericServiceException e) { Debug.logWarning(e.getMessage(), module); return ServiceUtil.returnError( "Could not create party relationship (write failure): " + e.getMessage()); } } } catch (GenericEntityException e) { Debug.logWarning(e.getMessage(), module); return ServiceUtil.returnError( "Could not create party relationship (write failure): " + e.getMessage()); } result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS); return result; }