@Override public boolean exec(MethodContext methodContext) { // if anything but false it will be true boolean setIfNull = !"false".equals(methodContext.expandString(setIfNullStr)); GenericValue value = valueAcsr.get(methodContext); if (value == null) { String errMsg = "In set-pk-fields a value was not found with the specified valueAcsr: " + valueAcsr + ", not setting fields"; Debug.logWarning(errMsg, module); if (methodContext.getMethodType() == MethodContext.EVENT) { methodContext.putEnv(simpleMethod.getEventErrorMessageName(), errMsg); methodContext.putEnv( simpleMethod.getEventResponseCodeName(), simpleMethod.getDefaultErrorCode()); } else if (methodContext.getMethodType() == MethodContext.SERVICE) { methodContext.putEnv(simpleMethod.getServiceErrorMessageName(), errMsg); methodContext.putEnv( simpleMethod.getServiceResponseMessageName(), simpleMethod.getDefaultErrorCode()); } return false; } Map<String, ? extends Object> theMap = mapAcsr.get(methodContext); if (theMap == null) { Debug.logWarning( "In set-pk-fields could not find map with name " + mapAcsr + ", not setting any fields", module); } else { value.setPKFields(theMap, setIfNull); } return true; }
public static Map<String, GenericValue> getPartyOtherValues( ServletRequest request, String partyId, String partyAttr, String personAttr, String partyGroupAttr) { Delegator delegator = (Delegator) request.getAttribute("delegator"); Map<String, GenericValue> result = FastMap.newInstance(); try { GenericValue party = delegator.findByPrimaryKey("Party", UtilMisc.toMap("partyId", partyId)); if (party != null) result.put(partyAttr, party); } catch (GenericEntityException e) { Debug.logWarning(e, "Problems getting Party entity", module); } try { GenericValue person = delegator.findByPrimaryKey("Person", UtilMisc.toMap("partyId", partyId)); if (person != null) result.put(personAttr, person); } catch (GenericEntityException e) { Debug.logWarning(e, "Problems getting Person entity", module); } try { GenericValue partyGroup = delegator.findByPrimaryKey("PartyGroup", UtilMisc.toMap("partyId", partyId)); if (partyGroup != null) result.put(partyGroupAttr, partyGroup); } catch (GenericEntityException e) { Debug.logWarning(e, "Problems getting PartyGroup entity", module); } return result; }
/** * Gets the request fields that are configured in the properties file, such as the merchant key * and password. This handles version as well. If some critical data is missing, this throws * GenericServiceException. */ private static Map buildRequestHeader(String resource) throws GenericServiceException { Map request = FastMap.newInstance(); String login = UtilProperties.getPropertyValue(resource, "payment.authorizedotnet.login"); if (UtilValidate.isEmpty(login)) { Debug.logWarning( "Authorize.NET login not configured. Please ensure payment.authorizedotnet.login is defined in " + resource, module); } String password = UtilProperties.getPropertyValue(resource, "payment.authorizedotnet.password"); if (UtilValidate.isEmpty(password)) { Debug.logWarning( "Authorize.NET password not configured. Please ensure payment.authorizedotnet.password is defined in " + resource, module); } String delimited = UtilProperties.getPropertyValue(resource, "payment.authorizedotnet.delimited"); String delimiter = UtilProperties.getPropertyValue(resource, "payment.authorizedotnet.delimiter"); String emailcustomer = UtilProperties.getPropertyValue(resource, "payment.authorizedotnet.emailcustomer"); String emailmerchant = UtilProperties.getPropertyValue(resource, "payment.authorizedotnet.emailmerchant"); String transdescription = UtilProperties.getPropertyValue(resource, "payment.authorizedotnet.transdescription"); request.put("x_login", login); request.put("x_password", password); request.put("x_delim_data", delimited); request.put("x_delim_char", delimiter); request.put("x_email_customer", emailcustomer); request.put("x_email_merchant", emailmerchant); request.put("x_description", transdescription); request.put("x_relay_response", "FALSE"); String version = UtilProperties.getPropertyValue(resource, "payment.authorizedotnet.version", "3.0"); String tkey = UtilProperties.getPropertyValue(resource, "payment.authorizedotnet.trankey"); // transaction key is only supported in 3.1 if ("3.1".equals(version) && UtilValidate.isNotEmpty(tkey)) { Debug.logWarning( "Version 3.1 of Authorize.NET requires a transaction key. Please define payment.authorizedotnet.trankey in " + resource, module); Debug.logWarning("Reverting to version 3.0 of Authorize.NET", module); version = "3.0"; } request.put("x_version", version); request.put("x_tran_key", tkey); return request; }
private boolean evalEntityPermission(Security security, GenericValue userLogin) { if (nameOrRole == null) { Debug.logWarning("Null permission name passed for evaluation", module); return false; } if (action == null) { Debug.logWarning("Null action passed for evaluation", module); } return security.hasEntityPermission(nameOrRole, action, userLogin); }
@Override public boolean exec(MethodContext methodContext) throws MiniLangException { List<Object> messages = errorListFma.get(methodContext.getEnvMap()); if (messages == null) { messages = new LinkedList<Object>(); errorListFma.put(methodContext.getEnvMap(), messages); } String location = this.locationFse.expandString(methodContext.getEnvMap()); Delegator delegator = getDelegator(methodContext); URL dataUrl = null; try { dataUrl = FlexibleLocation.resolveLocation(location, methodContext.getLoader()); } catch (MalformedURLException e) { messages.add( "Could not find Entity Data document in resource: " + location + "; error was: " + e.toString()); } if (dataUrl == null) { messages.add("Could not find Entity Data document in resource: " + location); } if ("assert".equals(mode)) { try { EntityDataAssert.assertData(dataUrl, delegator, messages); } catch (Exception e) { String xmlError = "Error checking/asserting XML Resource \"" + dataUrl.toExternalForm() + "\"; Error was: " + e.getMessage(); messages.add(xmlError); Debug.logWarning(e, xmlError, module); } } else { try { EntitySaxReader reader = null; if (timeout > 0) { reader = new EntitySaxReader(delegator, timeout); } else { reader = new EntitySaxReader(delegator); } reader.parse(dataUrl); } catch (Exception e) { String xmlError = "Error loading XML Resource \"" + dataUrl.toExternalForm() + "\"; Error was: " + e.getMessage(); messages.add(xmlError); Debug.logWarning(e, xmlError, module); } } return true; }
public static void checkPathAlias( ServletRequest request, ServletResponse response, Delegator delegator, String pathInfo) { HttpServletRequest httpRequest = (HttpServletRequest) request; HttpServletResponse httpResponse = (HttpServletResponse) response; String webSiteId = WebSiteWorker.getWebSiteId(request); // check path alias GenericValue pathAlias = null; try { pathAlias = EntityQuery.use(delegator) .from("WebSitePathAlias") .where("webSiteId", webSiteId, "pathAlias", pathInfo) .cache() .queryOne(); } catch (GenericEntityException e) { Debug.logError(e, module); } if (pathAlias != null) { String alias = pathAlias.getString("aliasTo"); String contentId = pathAlias.getString("contentId"); if (contentId == null && UtilValidate.isNotEmpty(alias)) { if (!alias.startsWith("/")) { alias = "/" + alias; } RequestDispatcher rd = request.getRequestDispatcher(alias); try { rd.forward(request, response); return; } catch (ServletException e) { Debug.logWarning(e, module); } catch (IOException e) { Debug.logWarning(e, module); } } } else { // send 404 error if a URI is alias TO try { List<GenericValue> aliasTos = EntityQuery.use(delegator) .from("WebSitePathAlias") .where("webSiteId", webSiteId, "aliasTo", httpRequest.getRequestURI()) .queryList(); if (UtilValidate.isNotEmpty(aliasTos)) { httpResponse.sendError(HttpServletResponse.SC_NOT_FOUND, "Not Found"); return; } } catch (GenericEntityException e) { Debug.logError(e, module); } catch (IOException e) { Debug.logError(e, module); } } }
/** * 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; }
/** * 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; }
/** * JavaMail Service that gets body content from a URL * * @param ctx The DispatchContext that this service is operating in * @param rcontext Map containing the input parameters * @return Map with the result of the service, the output parameters */ public static Map<String, Object> sendMailFromUrl( DispatchContext ctx, Map<String, ? extends Object> rcontext) { // pretty simple, get the content and then call the sendMail method below Map<String, Object> sendMailContext = UtilMisc.makeMapWritable(rcontext); String bodyUrl = (String) sendMailContext.remove("bodyUrl"); Map<String, Object> bodyUrlParameters = UtilGenerics.checkMap(sendMailContext.remove("bodyUrlParameters")); Locale locale = (Locale) rcontext.get("locale"); LocalDispatcher dispatcher = ctx.getDispatcher(); URL url = null; try { url = new URL(bodyUrl); } catch (MalformedURLException e) { Debug.logWarning(e, module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "CommonEmailSendMalformedUrl", UtilMisc.toMap("bodyUrl", bodyUrl, "errorString", e.toString()), locale)); } HttpClient httpClient = new HttpClient(url, bodyUrlParameters); String body = null; try { body = httpClient.post(); } catch (HttpClientException e) { Debug.logWarning(e, module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "CommonEmailSendGettingError", UtilMisc.toMap("errorString", e.toString()), locale)); } sendMailContext.put("body", body); Map<String, Object> sendMailResult; try { sendMailResult = dispatcher.runSync("sendMail", sendMailContext); } catch (GenericServiceException e) { Debug.logError(e, module); return ServiceUtil.returnError(e.getMessage()); } // just return the same result; it contains all necessary information return sendMailResult; }
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; }
@Override protected Object get(Map<String, ? extends Object> context, TimeZone timeZone, Locale locale) { try { Object obj = BshUtil.eval( new String(this.chars, this.parseStart, this.parseLength), UtilMisc.makeMapWritable(context)); if (obj != null) { return obj; } else { if (Debug.verboseOn()) { Debug.logVerbose( "BSH scriptlet evaluated to null [" + this + "], got no return so inserting nothing.", module); } } } catch (EvalError e) { Debug.logWarning( e, "Error evaluating BSH scriptlet [" + this + "], inserting nothing; error was: " + e, module); } return null; }
public boolean evalPermission(DispatchContext dctx, Map<String, ? extends Object> context) { GenericValue userLogin = (GenericValue) context.get("userLogin"); Authorization authz = dctx.getAuthorization(); Security security = dctx.getSecurity(); if (userLogin == null) { Debug.logInfo("Secure service requested with no userLogin object", module); return false; } switch (permissionType) { case PERMISSION: return evalAuthzPermission(authz, userLogin, context); case ENTITY_PERMISSION: return evalEntityPermission(security, userLogin); case ROLE_MEMBER: return evalRoleMember(userLogin); case PERMISSION_SERVICE: return evalPermissionService(serviceModel, dctx, context); default: Debug.logWarning( "Invalid permission type [" + permissionType + "] for permission named : " + nameOrRole + " on service : " + serviceModel.name, module); return false; } }
/** Simple event to set the users per-session currency uom value */ public static String setSessionCurrencyUom( HttpServletRequest request, HttpServletResponse response) { String currencyUom = request.getParameter("currencyUom"); if (UtilValidate.isNotEmpty(currencyUom)) { // update the session UtilHttp.setCurrencyUom(request.getSession(), currencyUom); // update the UserLogin object GenericValue userLogin = (GenericValue) request.getSession().getAttribute("userLogin"); if (userLogin == null) { userLogin = (GenericValue) request.getSession().getAttribute("autoUserLogin"); } if (userLogin != null) { GenericValue ulUpdate = GenericValue.create(userLogin); ulUpdate.set("lastCurrencyUom", currencyUom); try { ulUpdate.store(); userLogin.refreshFromCache(); } catch (GenericEntityException e) { Debug.logWarning(e, module); } } } return "success"; }
@Override public T getObject(MethodContext methodContext) { T fieldVal = null; if (!mapAcsr.isEmpty()) { Map<String, ? extends Object> fromMap = mapAcsr.get(methodContext); if (fromMap == null) { Debug.logWarning( "Map not found with name " + mapAcsr + ", not getting Object value, returning null.", module); return null; } fieldVal = fieldAcsr.get(fromMap, methodContext); } else { // no map name, try the env fieldVal = fieldAcsr.get(methodContext); } if (fieldVal == null) { if (Debug.infoOn()) Debug.logInfo( "Field value not found with name " + fieldAcsr + " in Map with name " + mapAcsr + ", not getting Object value, returning null.", module); return null; } return fieldVal; }
/** * 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(); }
@Override protected Object get(Map<String, ? extends Object> context, TimeZone timeZone, Locale locale) { try { Object obj = InvokerHelper.createScript(this.parsedScript, GroovyUtil.getBinding(context)).run(); if (obj != null) { return obj; } else { if (Debug.verboseOn()) { Debug.logVerbose( "Groovy scriptlet evaluated to null [" + this + "], got no return so inserting nothing.", module); } } } catch (Exception e) { // handle other things, like the groovy.lang.MissingPropertyException Debug.logWarning( e, "Error evaluating Groovy scriptlet [" + this + "], inserting nothing; error was: " + e, module); } return null; }
@Override public boolean exec(MethodContext methodContext) throws MiniLangException { try { Delegator delegator = getDelegator(methodContext); String entityName = this.entityNameFse.expandString(methodContext.getEnvMap()); ModelEntity modelEntity = delegator.getModelEntity(entityName); EntityCondition whereEntityCondition = null; if (this.whereCondition != null) { whereEntityCondition = this.whereCondition.createCondition( methodContext.getEnvMap(), modelEntity, delegator.getModelFieldTypeReader(modelEntity)); } EntityCondition havingEntityCondition = null; if (this.havingCondition != null) { havingEntityCondition = this.havingCondition.createCondition( methodContext.getEnvMap(), modelEntity, delegator.getModelFieldTypeReader(modelEntity)); } long count = delegator.findCountByCondition( entityName, whereEntityCondition, havingEntityCondition, null); this.countFma.put(methodContext.getEnvMap(), count); } catch (GeneralException e) { String errMsg = "Exception thrown while performing entity count: " + e.getMessage(); Debug.logWarning(e, errMsg, module); simpleMethod.addErrorMessage(methodContext, errMsg); return false; } return true; }
/** * 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; }
public static String getPartyName(GenericValue partyObject, boolean lastNameFirst) { if (partyObject == null) { return ""; } if ("PartyGroup".equals(partyObject.getEntityName()) || "Person".equals(partyObject.getEntityName())) { return formatPartyNameObject(partyObject, lastNameFirst); } else { String partyId = null; try { partyId = partyObject.getString("partyId"); } catch (IllegalArgumentException e) { Debug.logError(e, "Party object does not contain a party ID", module); } if (partyId == null) { Debug.logWarning( "No party ID found; cannot get name based on entity: " + partyObject.getEntityName(), module); return ""; } else { return getPartyName(partyObject.getDelegator(), partyId, lastNameFirst); } } }
public Object eval(String source, int lineNo, int columnNo, Object expr) throws BSFException { if (!(expr instanceof String)) throw new BSFException("simple-method expression must be a string"); // right now only supports one method per file, so get all methods and just run the first... Map<String, SimpleMethod> simpleMethods = null; try { simpleMethods = SimpleMethod.getDirectSimpleMethods(source, (String) expr, "<bsf source>"); } catch (MiniLangException e) { throw new BSFException("Error loading/parsing simple-method XML source: " + e.getMessage()); } Set<String> smNames = simpleMethods.keySet(); if (smNames.size() == 0) throw new BSFException("Did not find any simple-methods in the file"); String methodName = smNames.iterator().next(); if (smNames.size() > 1) Debug.logWarning( "Found more than one simple-method in the file, running the [" + methodName + "] method, you should remove all but one method from this file", module); SimpleMethod simpleMethod = simpleMethods.get(methodName); MethodContext methodContext = new MethodContext(context, null, MethodContext.EVENT); try { return simpleMethod.exec(methodContext); } catch (MiniLangException e) { throw new BSFException(e.getMessage()); } }
public LabelReferences(Delegator delegator, LabelManagerFactory factory) { this.delegator = delegator; this.labels = factory.getLabels(); DelegatorElement delegatorInfo = null; try { delegatorInfo = EntityConfigUtil.getDelegator(delegator.getDelegatorBaseName()); } catch (GenericEntityConfException e) { Debug.logWarning(e, "Exception thrown while getting delegator config: ", module); } String modelName; if (delegatorInfo != null) { modelName = delegatorInfo.getEntityModelReader(); } else { modelName = "main"; } // since we do not associate a dispatcher to this DispatchContext, it is important to set a name // of an existing entity model reader: // in this way it will be possible to retrieve the service models from the cache this.dispatchContext = new DispatchContext(modelName, this.getClass().getClassLoader(), null); Collection<LabelInfo> infoList = this.labels.values(); for (LabelInfo labelInfo : infoList) { this.labelSet.add(labelInfo.getLabelKey()); } Collection<ComponentConfig> componentConfigs = ComponentConfig.getAllComponents(); for (ComponentConfig config : componentConfigs) { String rootFolder = config.getRootLocation(); rootFolder = rootFolder.replace('\\', '/'); if (!rootFolder.endsWith("/")) { rootFolder = rootFolder + "/"; } this.rootFolders.add(rootFolder); } }
public void renderPortalPageBegin( Appendable writer, Map<String, Object> context, ModelScreenWidget.PortalPage portalPage) throws GeneralException, IOException { String portalPageId = portalPage.getActualPortalPageId(); String originalPortalPageId = portalPage.getOriginalPortalPageId(); String confMode = portalPage.getConfMode(context); Map<String, String> uiLabelMap = UtilGenerics.cast(context.get("uiLabelMap")); String addColumnLabel = ""; String addColumnHint = ""; if (uiLabelMap == null) { Debug.logWarning("Could not find uiLabelMap in context", module); } else { addColumnLabel = uiLabelMap.get("CommonAddColumn"); addColumnHint = uiLabelMap.get("CommonAddAColumnToThisPortalPage"); } StringWriter sr = new StringWriter(); sr.append("<@renderPortalPageBegin "); sr.append("originalPortalPageId=\""); sr.append(originalPortalPageId); sr.append("\" portalPageId=\""); sr.append(portalPageId); sr.append("\" confMode=\""); sr.append(confMode); sr.append("\" addColumnLabel=\""); sr.append(addColumnLabel); sr.append("\" addColumnHint=\""); sr.append(addColumnHint); sr.append("\" />"); executeMacro(writer, sr.toString()); }
public static String makeProductUrl( HttpServletRequest request, String previousCategoryId, String productCategoryId, String productId) { Delegator delegator = (Delegator) request.getAttribute("delegator"); String url = null; try { GenericValue product = EntityQuery.use(delegator) .from("Product") .where("productId", productId) .cache() .queryOne(); ProductContentWrapper wrapper = new ProductContentWrapper(product, request); List<String> trail = CategoryWorker.getTrail(request); url = makeProductUrl( delegator, wrapper, trail, request.getContextPath(), previousCategoryId, productCategoryId, productId); } catch (GenericEntityException e) { Debug.logWarning(e, "Cannot create product's URL for: " + productId, module); return redirectUrl; } return url; }
/** * Creates a PartyRelationshipType * * @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> createPartyRelationshipType( DispatchContext ctx, Map<String, ? extends Object> context) { Map<String, Object> result = FastMap.newInstance(); Delegator delegator = ctx.getDelegator(); Security security = ctx.getSecurity(); GenericValue userLogin = (GenericValue) context.get("userLogin"); ServiceUtil.getPartyIdCheckSecurity( userLogin, security, context, result, "PARTYMGR", "_CREATE"); if (result.size() > 0) return result; GenericValue partyRelationshipType = delegator.makeValue( "PartyRelationshipType", UtilMisc.toMap("partyRelationshipTypeId", context.get("partyRelationshipTypeId"))); partyRelationshipType.set("parentTypeId", context.get("parentTypeId"), true); partyRelationshipType.set("hasTable", context.get("hasTable"), true); partyRelationshipType.set("roleTypeIdValidFrom", context.get("roleTypeIdValidFrom"), true); partyRelationshipType.set("roleTypeIdValidTo", context.get("roleTypeIdValidTo"), false); partyRelationshipType.set("description", context.get("description"), true); partyRelationshipType.set("partyRelationshipName", context.get("partyRelationshipName"), true); try { if (delegator.findOne( partyRelationshipType.getEntityName(), partyRelationshipType.getPrimaryKey(), false) != null) { return ServiceUtil.returnError("Could not create party relationship type: already exists"); } } catch (GenericEntityException e) { Debug.logWarning(e, module); return ServiceUtil.returnError( "Could not create party relationship type (read failure): " + e.getMessage()); } try { partyRelationshipType.create(); } catch (GenericEntityException e) { Debug.logWarning(e.getMessage(), module); return ServiceUtil.returnError( "Could not create party relationship type (write failure): " + e.getMessage()); } result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS); return result; }
private boolean evalAuthzPermission( Authorization authz, GenericValue userLogin, Map<String, ? extends Object> context) { if (nameOrRole == null) { Debug.logWarning("Null permission name passed for evaluation", module); return false; } return authz.hasPermission(userLogin.getString("userLoginId"), nameOrRole, context); }
/** * Stores a user preference group in persistent storage. Call with userPrefMap, * 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> setUserPreferenceGroup( DispatchContext ctx, Map<String, ?> context) { Delegator delegator = ctx.getDelegator(); Locale locale = (Locale) context.get("locale"); String userLoginId = PreferenceWorker.getUserLoginId(context, false); Map<String, Object> userPrefMap = checkMap(context.get("userPrefMap"), String.class, Object.class); String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId"); if (UtilValidate.isEmpty(userLoginId) || UtilValidate.isEmpty(userPrefGroupTypeId) || userPrefMap == null) { return ServiceUtil.returnError( UtilProperties.getMessage(resource, "setPreference.invalidArgument", locale)); } try { for (Iterator i = userPrefMap.entrySet().iterator(); i.hasNext(); ) { Map.Entry mapEntry = (Map.Entry) i.next(); GenericValue rec = delegator.makeValidValue( "UserPreference", PreferenceWorker.toFieldMap( userLoginId, (String) mapEntry.getKey(), userPrefGroupTypeId, (String) mapEntry.getValue())); delegator.createOrStore(rec); } } catch (GenericEntityException e) { Debug.logWarning(e.getMessage(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "setPreference.writeFailure", new Object[] {e.getMessage()}, locale)); } catch (GeneralException e) { Debug.logWarning(e.getMessage(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "setPreference.writeFailure", new Object[] {e.getMessage()}, locale)); } return ServiceUtil.returnSuccess(); }
@Override public String toString() { StringBuilder sb = new StringBuilder(); ModelFieldVisitor visitor = new XmlWidgetFieldVisitor(sb); try { accept(visitor); } catch (Exception e) { Debug.logWarning(e, "Exception thrown in XmlWidgetFieldVisitor: ", module); } return sb.toString(); }
/** * Returns an appropriate <code>Converter</code> instance for <code>sourceClass</code> and <code> * targetClass</code>. If no matching <code>Converter</code> is found, the method throws <code> * ClassNotFoundException</code>. * * <p>This method is intended to be used when the source or target <code>Object</code> types are * unknown at compile time. If the source and target <code>Object</code> types are known at * compile time, then one of the "ready made" converters should be used. * * @param sourceClass The object class to convert from * @param targetClass The object class to convert to * @return A matching <code>Converter</code> instance * @throws ClassNotFoundException */ public static <S, T> Converter<S, T> getConverter(Class<S> sourceClass, Class<T> targetClass) throws ClassNotFoundException { String key = sourceClass.getName().concat(DELIMITER).concat(targetClass.getName()); if (Debug.verboseOn()) { Debug.logVerbose("Getting converter: " + key, module); } OUTER: do { Converter<?, ?> result = converterMap.get(key); if (result != null) { return UtilGenerics.cast(result); } if (noConversions.contains(key)) { throw new ClassNotFoundException("No converter found for " + key); } Class<?> foundSourceClass = null; Converter<?, ?> foundConverter = null; for (Converter<?, ?> value : converterMap.values()) { if (value.canConvert(sourceClass, targetClass)) { // this converter can deal with the source/target pair if (foundSourceClass == null || foundSourceClass.isAssignableFrom(value.getSourceClass())) { // remember the current target source class; if we find another converter, check // to see if it's source class is assignable to this one, and if so, it means it's // a child class, so we'll then take that converter. foundSourceClass = value.getSourceClass(); foundConverter = value; } } } if (foundConverter != null) { converterMap.putIfAbsent(key, foundConverter); continue OUTER; } for (ConverterCreator value : creators) { result = createConverter(value, sourceClass, targetClass); if (result != null) { converterMap.putIfAbsent(key, result); continue OUTER; } } if (noConversions.add(key)) { Debug.logWarning( "*** No converter found, converting from " + sourceClass.getName() + " to " + targetClass.getName() + ". Please report this message to the developer community so " + "a suitable converter can be created. ***", module); } throw new ClassNotFoundException("No converter found for " + key); } while (true); }
/** * Stores a single user preference in persistent storage. Call with userPrefTypeId, * userPrefGroupTypeId, userPrefValue 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> setUserPreference(DispatchContext ctx, Map<String, ?> context) { Delegator delegator = ctx.getDelegator(); Locale locale = (Locale) context.get("locale"); String userLoginId = PreferenceWorker.getUserLoginId(context, false); String userPrefTypeId = (String) context.get("userPrefTypeId"); Object userPrefValue = (String) context.get("userPrefValue"); if (UtilValidate.isEmpty(userLoginId) || UtilValidate.isEmpty(userPrefTypeId) || userPrefValue == null) { return ServiceUtil.returnError( UtilProperties.getMessage(resource, "setPreference.invalidArgument", locale)); } String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId"); String userPrefDataType = (String) context.get("userPrefDataType"); try { if (UtilValidate.isNotEmpty(userPrefDataType)) { userPrefValue = ObjectType.simpleTypeConvert(userPrefValue, userPrefDataType, null, null, false); } GenericValue rec = delegator.makeValidValue( "UserPreference", PreferenceWorker.toFieldMap( userLoginId, userPrefTypeId, userPrefGroupTypeId, userPrefValue)); delegator.createOrStore(rec); } catch (GenericEntityException e) { Debug.logWarning(e.getMessage(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "setPreference.writeFailure", new Object[] {e.getMessage()}, locale)); } catch (GeneralException e) { Debug.logWarning(e.getMessage(), module); return ServiceUtil.returnError( UtilProperties.getMessage( resource, "setPreference.writeFailure", new Object[] {e.getMessage()}, locale)); } return ServiceUtil.returnSuccess(); }
private static String translateAccountNumber(GenericValue eftAccount) { String accountNumber = eftAccount.getString("accountNumber").replaceAll("\\D", ""); if (accountNumber.length() > 20) { Debug.logWarning( "EftAccount with paymentMethodId [" + eftAccount.get("paymentMethodId") + "] has a accountNumber larger than 20 digits. Truncating to 20.", module); return accountNumber.substring(0, 20); } return accountNumber; }