View Javadoc

1   package org.andromda.cartridges.bpm4struts.metafacades;
2   
3   import java.util.ArrayList;
4   import java.util.Collection;
5   import java.util.HashMap;
6   import java.util.Iterator;
7   import java.util.LinkedHashMap;
8   import java.util.LinkedHashSet;
9   import java.util.List;
10  import java.util.Map;
11  import java.util.Set;
12  
13  import org.andromda.cartridges.bpm4struts.Bpm4StrutsGlobals;
14  import org.andromda.metafacades.uml.ClassifierFacade;
15  import org.andromda.metafacades.uml.DependencyFacade;
16  import org.andromda.metafacades.uml.EventFacade;
17  import org.andromda.metafacades.uml.FrontEndActivityGraph;
18  import org.andromda.metafacades.uml.FrontEndControllerOperation;
19  import org.andromda.metafacades.uml.ModelElementFacade;
20  import org.andromda.metafacades.uml.OperationFacade;
21  import org.andromda.metafacades.uml.ParameterFacade;
22  import org.andromda.metafacades.uml.ServiceOperation;
23  import org.andromda.metafacades.uml.StateVertexFacade;
24  import org.andromda.utils.StringUtilsHelper;
25  
26  
27  /**
28   * MetafacadeLogic implementation for org.andromda.cartridges.bpm4struts.metafacades.StrutsControllerOperation.
29   *
30   * @see org.andromda.cartridges.bpm4struts.metafacades.StrutsControllerOperation
31   */
32  public class StrutsControllerOperationLogicImpl
33      extends StrutsControllerOperationLogic
34  {
35      public StrutsControllerOperationLogicImpl(
36          Object metaObject,
37          String context)
38      {
39          super(metaObject, context);
40      }
41  
42      protected String handleGetInterfaceName()
43      {
44          return StringUtilsHelper.upperCamelCaseName(getName()) + Bpm4StrutsGlobals.FORM_SUFFIX;
45      }
46  
47      protected String handleGetInterfacePackageName()
48      {
49          return getOwner().getPackageName();
50      }
51  
52      protected String handleGetInterfaceType()
53      {
54          return getInterfacePackageName() + '.' + getInterfaceName();
55      }
56  
57      protected String handleGetInterfaceFullPath()
58      {
59          return '/' + getInterfaceType().replace('.', '/');
60      }
61  
62      /**
63       * Overridden because StrutsAction does not extend FrontEndAction.
64       *
65       * @see org.andromda.metafacades.uml.FrontEndControllerOperation#getDeferringActions()
66       */
67      public java.util.List getDeferringActions()
68      {
69          final Collection deferringActions = new LinkedHashSet();
70  
71          final FrontEndActivityGraph graph = getActivityGraph();
72          if (graph != null)
73          {
74              final Collection actionStates = graph.getActionStates();
75              for (final Iterator actionStateIterator = actionStates.iterator(); actionStateIterator.hasNext();)
76              {
77                  final Object actionStateObject = actionStateIterator.next();
78                  if (actionStateObject instanceof StrutsActionState)
79                  {
80                      final StrutsActionState actionState = (StrutsActionState)actionStateObject;
81                      final Collection controllerCalls = actionState.getControllerCalls();
82                      for (final Iterator controllerCallIterator = controllerCalls.iterator();
83                           controllerCallIterator.hasNext();)
84                      {
85                          final OperationFacade operation = (OperationFacade)controllerCallIterator.next();
86                          if (this.equals(operation))
87                          {
88                              deferringActions.addAll(actionState.getContainerActions());
89                          }
90                      }
91                  }
92              }
93  
94              final Collection transitions = graph.getTransitions();
95              for (final Iterator transitionIterator = transitions.iterator(); transitionIterator.hasNext();)
96              {
97                  final StrutsForward transition = (StrutsForward)transitionIterator.next();
98                  final EventFacade event = transition.getTrigger();
99                  if (event instanceof StrutsTrigger)
100                 {
101                     final StrutsTrigger trigger = (StrutsTrigger)event;
102                     final FrontEndControllerOperation operation = trigger.getControllerCall();
103                     if (this.equals(operation))
104                     {
105                         // we have two types of controller calls: the ones in action states and the ones for decisions
106                         final StateVertexFacade source = transition.getSource();
107                         if (source instanceof StrutsActionState)
108                         {
109                             final StrutsActionState sourceActionState = (StrutsActionState)source;
110                             deferringActions.addAll(sourceActionState.getContainerActions());
111                         }
112 
113                         // test for decision
114                         final StateVertexFacade target = transition.getTarget();
115                         if (target instanceof StrutsPseudostate)
116                         {
117                             final StrutsPseudostate targetPseudoState = (StrutsPseudostate)target;
118                             if (targetPseudoState.isDecisionPoint())
119                             {
120                                 deferringActions.addAll(targetPseudoState.getContainerActions());
121                             }
122                         }
123                     }
124                 }
125             }
126         }
127         return new ArrayList(deferringActions);
128     }
129 
130     protected Object handleGetController()
131     {
132         final Object owner = getOwner();
133         return (owner instanceof StrutsController) ? owner : null;
134     }
135 
136     /**
137      * Overridden since StrutsAction does not extend FrontEndAction.
138      *
139      * @see org.andromda.metafacades.uml.FrontEndControllerOperation#getFormFields()
140      */
141     public List getFormFields()
142     {
143         final Map formFieldsMap = new LinkedHashMap();
144 
145         // for quick lookup we use a hashset for the argument names, we only consider parameters with a name
146         // which is also present in this set
147         final Set argumentNames = new LinkedHashSet();
148         final Collection arguments = this.getArguments();
149         for (final Iterator argumentIterator = arguments.iterator(); argumentIterator.hasNext();)
150         {
151             final ModelElementFacade element = (ModelElementFacade)argumentIterator.next();
152             argumentNames.add(element.getName());
153         }
154 
155         // get all actions deferring to this operation
156         final List deferringActions = this.getDeferringActions();
157         for (int i = 0; i < deferringActions.size(); i++)
158         {
159             final StrutsAction action = (StrutsAction)deferringActions.get(i);
160             // store the action parameters
161             final List actionFormFields = action.getActionFormFields();
162             for (int j = 0; j < actionFormFields.size(); j++)
163             {
164                 final ModelElementFacade parameter = (ModelElementFacade)actionFormFields.get(j);
165                 if (argumentNames.contains(parameter.getName()))
166                 {
167                     formFieldsMap.put(parameter.getName(), parameter);
168                 }
169             }
170             // get all forwards and overwrite when we find a table (or add when not yet present)
171             final List forwards = action.getActionForwards();
172             for (int j = 0; j < forwards.size(); j++)
173             {
174                 final StrutsForward forward = (StrutsForward)forwards.get(j);
175                 // only consider forwards directly entering a page
176                 if (forward.isEnteringPage())
177                 {
178                     final List pageVariables = forward.getForwardParameters();
179                     for (int k = 0; k < pageVariables.size(); k++)
180                     {
181                         final StrutsParameter pageVariable = (StrutsParameter)pageVariables.get(k);
182                         if (argumentNames.contains(pageVariable.getName()))
183                         {
184                             if (!formFieldsMap.containsKey(pageVariable.getName()) || pageVariable.isTable())
185                             {
186                                 formFieldsMap.put(pageVariable.getName(), pageVariable);
187                             }
188                         }
189                     }
190                 }
191             }
192         }
193 
194         // since all arguments need to be present we add those that haven't yet been stored in the map
195         for (final Iterator argumentIterator = arguments.iterator(); argumentIterator.hasNext();)
196         {
197             final StrutsParameter argument = (StrutsParameter)argumentIterator.next();
198             if (!formFieldsMap.containsKey(argument.getName()))
199             {
200                 formFieldsMap.put(argument.getName(), argument);
201             }
202         }
203 
204         return new ArrayList(formFieldsMap.values());
205     }
206 
207     /**
208      * Overridden because StrutsAction does not extend FrontEndAction
209      * 
210      * @see org.andromda.metafacades.uml.FrontEndControllerOperation#isAllArgumentsHaveFormFields()
211      */
212     public boolean isAllArgumentsHaveFormFields()
213     {
214         final Collection arguments = this.getArguments();
215         final Collection deferringActions = this.getDeferringActions();
216 
217         boolean allArgumentsHaveFormFields = true;
218         for (final Iterator iterator = arguments.iterator(); iterator.hasNext() && allArgumentsHaveFormFields;)
219         {
220             final ParameterFacade parameter = (ParameterFacade)iterator.next();
221             final String parameterName = parameter.getName();
222             final ClassifierFacade parameterType = parameter.getType();
223             final String parameterTypeName = parameterType != null ? parameterType.getFullyQualifiedName() : "";
224 
225             boolean actionMissingField = false;
226             for (final Iterator actionIterator = deferringActions.iterator();
227                 actionIterator.hasNext() && !actionMissingField;)
228             {
229                 final StrutsAction action = (StrutsAction)actionIterator.next();
230                 final Collection actionFormFields = action.getActionFormFields();
231 
232                 boolean fieldPresent = false;
233                 for (final Iterator fieldIterator = actionFormFields.iterator();
234                     fieldIterator.hasNext() && !fieldPresent;)
235                 {
236                     final ParameterFacade field = (ParameterFacade)fieldIterator.next();
237                     final ClassifierFacade fieldType = field.getType();
238                     final String fieldTypeName = fieldType != null ? fieldType.getFullyQualifiedName() : "";
239                     if (parameterName.equals(field.getName()) && parameterTypeName.equals(fieldTypeName))
240                     {
241                         fieldPresent = true;
242                     }
243                 }
244                 actionMissingField = !fieldPresent;
245             }
246             allArgumentsHaveFormFields = !actionMissingField;
247         }
248         return allArgumentsHaveFormFields;
249     }
250 
251     protected boolean handleIsBackEndServiceOperationMatchingParameters()
252     {
253         boolean matches = true;
254 
255         final ServiceOperation serviceOperation = getBackEndServiceOperation();
256 
257         // cache this operation's parameters for easy lookup
258         final Map parameterMap = new HashMap();
259         final Collection controllerParameters = getParameters();
260         for (final Iterator iterator = controllerParameters.iterator(); iterator.hasNext();)
261         {
262             final ParameterFacade parameter = (ParameterFacade)iterator.next();
263             parameterMap.put(parameter.getName(), parameter.getType());
264         }
265 
266         // make sure that any service parameter exists here too
267         final Collection serviceParameters = serviceOperation.getParameters();
268         for (final Iterator iterator = serviceParameters.iterator(); iterator.hasNext() && matches;)
269         {
270             final ParameterFacade serviceParameter = (ParameterFacade)iterator.next();
271             final ClassifierFacade controllerParameterType = (ClassifierFacade)parameterMap.get(
272                 serviceParameter.getName());
273             matches = (controllerParameterType != null) && controllerParameterType.equals(serviceParameter.getType());
274         }
275 
276         return matches;
277     }
278 
279     protected Object handleGetBackEndServiceOperation()
280     {
281         Object operation = null;
282 
283         final Collection dependencies = getSourceDependencies();
284         for (final Iterator dependencyIterator = dependencies.iterator();
285              dependencyIterator.hasNext() && operation == null;)
286         {
287             final DependencyFacade dependency = (DependencyFacade)dependencyIterator.next();
288             final Object target = dependency.getTargetElement();
289             if (target instanceof ServiceOperation)
290             {
291                 operation = target;
292             }
293         }
294 
295         return operation;
296     }
297 
298     protected boolean handleIsCallingBackEnd()
299     {
300         return getBackEndServiceOperation() != null;
301     }
302 }