001: package org.andromda.cartridges.bpm4struts.metafacades;
002:
003: import java.util.ArrayList;
004: import java.util.Collection;
005: import java.util.HashMap;
006: import java.util.Iterator;
007: import java.util.LinkedHashMap;
008: import java.util.LinkedHashSet;
009: import java.util.List;
010: import java.util.Map;
011: import java.util.Set;
012:
013: import org.andromda.cartridges.bpm4struts.Bpm4StrutsGlobals;
014: import org.andromda.metafacades.uml.ClassifierFacade;
015: import org.andromda.metafacades.uml.DependencyFacade;
016: import org.andromda.metafacades.uml.EventFacade;
017: import org.andromda.metafacades.uml.FrontEndActivityGraph;
018: import org.andromda.metafacades.uml.FrontEndControllerOperation;
019: import org.andromda.metafacades.uml.ModelElementFacade;
020: import org.andromda.metafacades.uml.OperationFacade;
021: import org.andromda.metafacades.uml.ParameterFacade;
022: import org.andromda.metafacades.uml.ServiceOperation;
023: import org.andromda.metafacades.uml.StateVertexFacade;
024: import org.andromda.utils.StringUtilsHelper;
025:
026: /**
027: * MetafacadeLogic implementation for org.andromda.cartridges.bpm4struts.metafacades.StrutsControllerOperation.
028: *
029: * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsControllerOperation
030: */
031: public class StrutsControllerOperationLogicImpl extends
032: StrutsControllerOperationLogic {
033: public StrutsControllerOperationLogicImpl(Object metaObject,
034: String context) {
035: super (metaObject, context);
036: }
037:
038: protected String handleGetInterfaceName() {
039: return StringUtilsHelper.upperCamelCaseName(getName())
040: + Bpm4StrutsGlobals.FORM_SUFFIX;
041: }
042:
043: protected String handleGetInterfacePackageName() {
044: return getOwner().getPackageName();
045: }
046:
047: protected String handleGetInterfaceType() {
048: return getInterfacePackageName() + '.' + getInterfaceName();
049: }
050:
051: protected String handleGetInterfaceFullPath() {
052: return '/' + getInterfaceType().replace('.', '/');
053: }
054:
055: /**
056: * Overridden because StrutsAction does not extend FrontEndAction.
057: *
058: * @see org.andromda.metafacades.uml.FrontEndControllerOperation#getDeferringActions()
059: */
060: public java.util.List getDeferringActions() {
061: final Collection deferringActions = new LinkedHashSet();
062:
063: final FrontEndActivityGraph graph = getActivityGraph();
064: if (graph != null) {
065: final Collection actionStates = graph.getActionStates();
066: for (final Iterator actionStateIterator = actionStates
067: .iterator(); actionStateIterator.hasNext();) {
068: final Object actionStateObject = actionStateIterator
069: .next();
070: if (actionStateObject instanceof StrutsActionState) {
071: final StrutsActionState actionState = (StrutsActionState) actionStateObject;
072: final Collection controllerCalls = actionState
073: .getControllerCalls();
074: for (final Iterator controllerCallIterator = controllerCalls
075: .iterator(); controllerCallIterator
076: .hasNext();) {
077: final OperationFacade operation = (OperationFacade) controllerCallIterator
078: .next();
079: if (this .equals(operation)) {
080: deferringActions.addAll(actionState
081: .getContainerActions());
082: }
083: }
084: }
085: }
086:
087: final Collection transitions = graph.getTransitions();
088: for (final Iterator transitionIterator = transitions
089: .iterator(); transitionIterator.hasNext();) {
090: final StrutsForward transition = (StrutsForward) transitionIterator
091: .next();
092: final EventFacade event = transition.getTrigger();
093: if (event instanceof StrutsTrigger) {
094: final StrutsTrigger trigger = (StrutsTrigger) event;
095: final FrontEndControllerOperation operation = trigger
096: .getControllerCall();
097: if (this .equals(operation)) {
098: // we have two types of controller calls: the ones in action states and the ones for decisions
099: final StateVertexFacade source = transition
100: .getSource();
101: if (source instanceof StrutsActionState) {
102: final StrutsActionState sourceActionState = (StrutsActionState) source;
103: deferringActions.addAll(sourceActionState
104: .getContainerActions());
105: }
106:
107: // test for decision
108: final StateVertexFacade target = transition
109: .getTarget();
110: if (target instanceof StrutsPseudostate) {
111: final StrutsPseudostate targetPseudoState = (StrutsPseudostate) target;
112: if (targetPseudoState.isDecisionPoint()) {
113: deferringActions
114: .addAll(targetPseudoState
115: .getContainerActions());
116: }
117: }
118: }
119: }
120: }
121: }
122: return new ArrayList(deferringActions);
123: }
124:
125: protected Object handleGetController() {
126: final Object owner = getOwner();
127: return (owner instanceof StrutsController) ? owner : null;
128: }
129:
130: /**
131: * Overridden since StrutsAction does not extend FrontEndAction.
132: *
133: * @see org.andromda.metafacades.uml.FrontEndControllerOperation#getFormFields()
134: */
135: public List getFormFields() {
136: final Map formFieldsMap = new LinkedHashMap();
137:
138: // for quick lookup we use a hashset for the argument names, we only consider parameters with a name
139: // which is also present in this set
140: final Set argumentNames = new LinkedHashSet();
141: final Collection arguments = this .getArguments();
142: for (final Iterator argumentIterator = arguments.iterator(); argumentIterator
143: .hasNext();) {
144: final ModelElementFacade element = (ModelElementFacade) argumentIterator
145: .next();
146: argumentNames.add(element.getName());
147: }
148:
149: // get all actions deferring to this operation
150: final List deferringActions = this .getDeferringActions();
151: for (int i = 0; i < deferringActions.size(); i++) {
152: final StrutsAction action = (StrutsAction) deferringActions
153: .get(i);
154: // store the action parameters
155: final List actionFormFields = action.getActionFormFields();
156: for (int j = 0; j < actionFormFields.size(); j++) {
157: final ModelElementFacade parameter = (ModelElementFacade) actionFormFields
158: .get(j);
159: if (argumentNames.contains(parameter.getName())) {
160: formFieldsMap.put(parameter.getName(), parameter);
161: }
162: }
163: // get all forwards and overwrite when we find a table (or add when not yet present)
164: final List forwards = action.getActionForwards();
165: for (int j = 0; j < forwards.size(); j++) {
166: final StrutsForward forward = (StrutsForward) forwards
167: .get(j);
168: // only consider forwards directly entering a page
169: if (forward.isEnteringPage()) {
170: final List pageVariables = forward
171: .getForwardParameters();
172: for (int k = 0; k < pageVariables.size(); k++) {
173: final StrutsParameter pageVariable = (StrutsParameter) pageVariables
174: .get(k);
175: if (argumentNames.contains(pageVariable
176: .getName())) {
177: if (!formFieldsMap.containsKey(pageVariable
178: .getName())
179: || pageVariable.isTable()) {
180: formFieldsMap.put(pageVariable
181: .getName(), pageVariable);
182: }
183: }
184: }
185: }
186: }
187: }
188:
189: // since all arguments need to be present we add those that haven't yet been stored in the map
190: for (final Iterator argumentIterator = arguments.iterator(); argumentIterator
191: .hasNext();) {
192: final StrutsParameter argument = (StrutsParameter) argumentIterator
193: .next();
194: if (!formFieldsMap.containsKey(argument.getName())) {
195: formFieldsMap.put(argument.getName(), argument);
196: }
197: }
198:
199: return new ArrayList(formFieldsMap.values());
200: }
201:
202: /**
203: * Overridden because StrutsAction does not extend FrontEndAction
204: *
205: * @see org.andromda.metafacades.uml.FrontEndControllerOperation#isAllArgumentsHaveFormFields()
206: */
207: public boolean isAllArgumentsHaveFormFields() {
208: final Collection arguments = this .getArguments();
209: final Collection deferringActions = this .getDeferringActions();
210:
211: boolean allArgumentsHaveFormFields = true;
212: for (final Iterator iterator = arguments.iterator(); iterator
213: .hasNext()
214: && allArgumentsHaveFormFields;) {
215: final ParameterFacade parameter = (ParameterFacade) iterator
216: .next();
217: final String parameterName = parameter.getName();
218: final ClassifierFacade parameterType = parameter.getType();
219: final String parameterTypeName = parameterType != null ? parameterType
220: .getFullyQualifiedName()
221: : "";
222:
223: boolean actionMissingField = false;
224: for (final Iterator actionIterator = deferringActions
225: .iterator(); actionIterator.hasNext()
226: && !actionMissingField;) {
227: final StrutsAction action = (StrutsAction) actionIterator
228: .next();
229: final Collection actionFormFields = action
230: .getActionFormFields();
231:
232: boolean fieldPresent = false;
233: for (final Iterator fieldIterator = actionFormFields
234: .iterator(); fieldIterator.hasNext()
235: && !fieldPresent;) {
236: final ParameterFacade field = (ParameterFacade) fieldIterator
237: .next();
238: final ClassifierFacade fieldType = field.getType();
239: final String fieldTypeName = fieldType != null ? fieldType
240: .getFullyQualifiedName()
241: : "";
242: if (parameterName.equals(field.getName())
243: && parameterTypeName.equals(fieldTypeName)) {
244: fieldPresent = true;
245: }
246: }
247: actionMissingField = !fieldPresent;
248: }
249: allArgumentsHaveFormFields = !actionMissingField;
250: }
251: return allArgumentsHaveFormFields;
252: }
253:
254: protected boolean handleIsBackEndServiceOperationMatchingParameters() {
255: boolean matches = true;
256:
257: final ServiceOperation serviceOperation = getBackEndServiceOperation();
258:
259: // cache this operation's parameters for easy lookup
260: final Map parameterMap = new HashMap();
261: final Collection controllerParameters = getParameters();
262: for (final Iterator iterator = controllerParameters.iterator(); iterator
263: .hasNext();) {
264: final ParameterFacade parameter = (ParameterFacade) iterator
265: .next();
266: parameterMap.put(parameter.getName(), parameter.getType());
267: }
268:
269: // make sure that any service parameter exists here too
270: final Collection serviceParameters = serviceOperation
271: .getParameters();
272: for (final Iterator iterator = serviceParameters.iterator(); iterator
273: .hasNext()
274: && matches;) {
275: final ParameterFacade serviceParameter = (ParameterFacade) iterator
276: .next();
277: final ClassifierFacade controllerParameterType = (ClassifierFacade) parameterMap
278: .get(serviceParameter.getName());
279: matches = (controllerParameterType != null)
280: && controllerParameterType.equals(serviceParameter
281: .getType());
282: }
283:
284: return matches;
285: }
286:
287: protected Object handleGetBackEndServiceOperation() {
288: Object operation = null;
289:
290: final Collection dependencies = getSourceDependencies();
291: for (final Iterator dependencyIterator = dependencies
292: .iterator(); dependencyIterator.hasNext()
293: && operation == null;) {
294: final DependencyFacade dependency = (DependencyFacade) dependencyIterator
295: .next();
296: final Object target = dependency.getTargetElement();
297: if (target instanceof ServiceOperation) {
298: operation = target;
299: }
300: }
301:
302: return operation;
303: }
304:
305: protected boolean handleIsCallingBackEnd() {
306: return getBackEndServiceOperation() != null;
307: }
308: }
|