001 package edu.sampleu.krms.impl;
002
003 import org.kuali.rice.core.api.resourceloader.GlobalResourceLoader;
004 import org.kuali.rice.core.api.uif.RemotableAttributeError;
005 import org.kuali.rice.krms.api.KrmsApiServiceLocator;
006 import org.kuali.rice.krms.api.repository.function.FunctionDefinition;
007 import org.kuali.rice.krms.api.repository.function.FunctionRepositoryService;
008 import org.kuali.rice.krms.api.repository.operator.CustomOperator;
009 import org.kuali.rice.krms.api.repository.type.KrmsTypeDefinition;
010 import org.kuali.rice.krms.api.repository.type.KrmsTypeRepositoryService;
011 import org.kuali.rice.krms.framework.engine.Function;
012 import org.kuali.rice.krms.framework.type.FunctionTypeService;
013 import org.kuali.rice.krms.impl.repository.FunctionBoService;
014
015 import java.text.MessageFormat;
016 import java.util.ArrayList;
017 import java.util.Collection;
018 import java.util.Collections;
019 import java.util.List;
020
021 /**
022 * An example CustomOperator to demonstrate this functionality in of the KRMS UI and engine.
023 *
024 * <p>This one also does the FunctionTypeService duties to produce the engine executable, though that responsibility
025 * could be extracted to a separate class if desired, though that would require more wiring and database configuration.
026 * </p>
027 *
028 * <p>This implementation cheats a bit for easy configuration by persisting the FunctionDefinition on first access.
029 * The only prerequisite configuration to use it: 1) add a KRMS type with namespace "KR-SAP", name "contains operator",
030 * and the serviceName "sampleAppContainsOperatorService". 2) add a type relation of type 'A' (usage allowed) from
031 * your KRMS type to the context type you want to use it with.</p>
032 *
033 * <p>This service implementation is wired up in Spring and exported to the service bus.</p>
034 *
035 * <!-- NOTE: all ID and FK columns in the example SQL below should be replaced appropriately, but you knew that. -->
036 *
037 * <!-- sample SQL for creating the KRMS type:
038 * insert into krms_typ_t (typ_id, nm, nmspc_cd, srvc_nm, actv, ver_nbr)
039 * values ('OPERATOR-KRMS-TYPE-ID', 'contains operator', 'KR-SAP', 'sampleAppContainsOperatorService', 'Y', 1);
040 * -->
041 *
042 * <!-- sample SQL for creating the type relation:
043 * insert into krms_typ_reln_t (typ_reln_id, from_typ_id, to_typ_id, reln_typ, seq_no)
044 * values ('A-UNIQUE-ID', 'CONTEXT-TYPE-ID', 'OPERATOR-KRMS-TYPE-ID', 'A', 1);
045 * -->
046 *
047 * @author Kuali Rice Team (rice.collab@kuali.org)
048 */
049 public class ContainsOperator implements CustomOperator, FunctionTypeService {
050
051 /**
052 * Returns the FunctionDefinition for the custom function the executable portion of this CustomOperator will
053 * call.
054 *
055 * <p>If the FunctionDefinition hasn't been persisted yet, this method will persist it and then return it.</p>
056 *
057 * <p>Note that having the KRMS type for this </p>
058 *
059 * @return
060 */
061 @Override
062 public FunctionDefinition getOperatorFunctionDefinition() {
063 FunctionBoService functionBoService =
064 (FunctionBoService) GlobalResourceLoader.getService("functionRepositoryService");
065
066 KrmsTypeRepositoryService typeRepository = KrmsApiServiceLocator.getKrmsTypeRepositoryService();
067 KrmsTypeDefinition containsOperatorType = typeRepository.getTypeByName("KR-SAP", "contains operator");
068
069 if (containsOperatorType == null) {
070 throw new IllegalStateException("There must be a persisted KRMS type with namespace 'KR-SAP', "
071 + "name 'contains operator', and serviceName 'sampleAppContainsOperatorService'");
072 }
073
074 FunctionDefinition containsFunction = functionBoService.getFunctionByNameAndNamespace("contains", "KR-SAP");
075
076 if (containsFunction == null) {
077 FunctionDefinition.Builder functionBuilder =
078 FunctionDefinition.Builder.create("KR-SAP", "contains", "java.lang.Boolean", containsOperatorType.getId());
079
080 containsFunction = functionBoService.createFunction(functionBuilder.build());
081 }
082
083 return containsFunction;
084 }
085
086 /**
087 * Validate the argument types. This operator supports (String, String), and (Collection, Object). For other
088 * classes, errors will be produced. Note that at the current time (Rice 2.3.1), the rhsClassName will always be
089 * "java.lang.String" since the UI is constrained to set the second arg as a constant value.
090 *
091 * @param lhsClassName the class name for the left hand side operand
092 * @param rhsClassName the class name for the right hand side operand
093 * @return errors
094 */
095 @Override
096 public List<RemotableAttributeError> validateOperandClasses(String lhsClassName, String rhsClassName) {
097 List<RemotableAttributeError> errors = new ArrayList<RemotableAttributeError>();
098
099 if (String.class.getName().equals(lhsClassName)) {
100 if (!String.class.getName().equals(rhsClassName)) {
101 RemotableAttributeError.Builder errorBuilder =
102 RemotableAttributeError.Builder.create("operator", "right hand operand is not a String");
103 errors.add(errorBuilder.build());
104 }
105 } else {
106 try {
107 Class<?> clazz = getClass().getClassLoader().loadClass(lhsClassName);
108
109 if (!Collection.class.isAssignableFrom(clazz)) {
110 RemotableAttributeError.Builder errorBuilder =
111 RemotableAttributeError.Builder.create("operator", "left hand operand is not a Collection");
112 errors.add(errorBuilder.build());
113 }
114 } catch (ClassNotFoundException e) {
115 // it is not a class available to the class loader so we can't determine if it extends Collection or not
116 }
117 }
118
119 return errors;
120 }
121
122 /**
123 * Loads the Function object that the KRMS engine can execute during rule evaluation
124 *
125 * @param functionDefinition {@link FunctionDefinition} to create the {@link Function} from.
126 * @return
127 */
128 @Override
129 public Function loadFunction(FunctionDefinition functionDefinition) {
130 if (!"contains".equals(functionDefinition.getName()) || "KR-SAP".equals(functionDefinition.getNamespace())) {
131 throw new IllegalArgumentException("oops, you have the wrong type service, I can't load this function");
132 }
133
134 // return our KRMS engine executable operator function:
135 return new Function() {
136 @Override
137 public Object invoke(Object... arguments) {
138 if (arguments.length != 2) {
139 throw new IllegalArgumentException("contains operator expects 2 arguments");
140 }
141
142 if (arguments[0] instanceof String) {
143 if (arguments[1] instanceof String) {
144 return Boolean.valueOf(((String)arguments[0]).contains((String)arguments[1]));
145 } else {
146 throw new IllegalArgumentException("if the first argument is a String, the second argument "
147 + "must be as well");
148 }
149 } else if (arguments[0] instanceof Collection) {
150 return Boolean.valueOf(((Collection)arguments[0]).contains(arguments[1]));
151 }
152
153 throw new IllegalArgumentException("argument types must be either (String, String) or (Collection, Object)");
154 }
155 };
156 }
157 }