View Javadoc

1   /**
2    * This file Copyright (c) 2003-2010 Magnolia International
3    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
4    *
5    *
6    * This file is dual-licensed under both the Magnolia
7    * Network Agreement and the GNU General Public License.
8    * You may elect to use one or the other of these licenses.
9    *
10   * This file is distributed in the hope that it will be
11   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
12   * implied warranty of MERCHANTABILITY or FITNESS FOR A
13   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
14   * Redistribution, except as permitted by whichever of the GPL
15   * or MNA you select, is prohibited.
16   *
17   * 1. For the GPL license (GPL), you can redistribute and/or
18   * modify this file under the terms of the GNU General
19   * Public License, Version 3, as published by the Free Software
20   * Foundation.  You should have received a copy of the GNU
21   * General Public License, Version 3 along with this program;
22   * if not, write to the Free Software Foundation, Inc., 51
23   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
24   *
25   * 2. For the Magnolia Network Agreement (MNA), this file
26   * and the accompanying materials are made available under the
27   * terms of the MNA which accompanies this distribution, and
28   * is available at http://www.magnolia-cms.com/mna.html
29   *
30   * Any modifications to this file must keep this entire header
31   * intact.
32   *
33   */
34  package info.magnolia.module.workflow;
35  
36  import info.magnolia.commands.CommandsManager;
37  import info.magnolia.context.Context;
38  import info.magnolia.context.MgnlContext;
39  import openwfe.org.embed.impl.engine.AbstractEmbeddedParticipant;
40  import openwfe.org.engine.workitem.CancelItem;
41  import openwfe.org.engine.workitem.InFlowWorkItem;
42  import openwfe.org.engine.workitem.WorkItem;
43  
44  import org.apache.commons.chain.Command;
45  import org.apache.commons.lang.StringUtils;
46  import org.slf4j.Logger;
47  import org.slf4j.LoggerFactory;
48  
49  
50  /**
51   * The Magnolia-specific workflow participant.
52   * @author Jackie Ju
53   * @author Philipp Bracher
54   * @author Nicolas Modrzyk
55   * @author John Mettraux
56   */
57  public class MgnlParticipant extends AbstractEmbeddedParticipant {
58      private static final Logger log = LoggerFactory.getLogger(AbstractEmbeddedParticipant.class);
59  
60      public MgnlParticipant() throws Exception {
61          super();
62      }
63  
64      public MgnlParticipant(String name) throws Exception {
65          super(name);
66      }
67  
68      public void cancel(CancelItem cancelItem) throws Exception {
69          if (log.isDebugEnabled()) {
70              if (cancelItem.getId() != null) {
71                  log.debug("Cancelling {}", cancelItem.getId().toParseableString());
72              }
73  
74          }
75          Context originalContext = null;
76          if (MgnlContext.hasInstance()) {
77              originalContext = MgnlContext.getInstance();
78          }
79          try {
80              String parName = cancelItem.getParticipantName();
81              if (!parName.startsWith(WorkflowConstants.PARTICIPANT_PREFIX_COMMAND)) {
82                  //
83                  // remove workitem from inbox
84                  MgnlContext.setInstance(MgnlContext.getSystemContext());
85                  WorkflowUtil.getWorkItemStore().removeWorkItem(cancelItem.getId());
86              }
87          } finally {
88              MgnlContext.release();
89              MgnlContext.setInstance(originalContext);
90          }
91      }
92  
93      public void consume(WorkItem wi) throws Exception {
94  
95          // get participant name
96          log.debug("Enter consume()..");
97  
98          if (wi == null) {
99              log.error("Work item is null");
100             return;
101         }
102         String parName = ((InFlowWorkItem) (wi)).getParticipantName();
103 
104         log.debug("Participant name = {}", parName);
105 
106         Context originalContext = null;
107         if (MgnlContext.hasInstance()) {
108             originalContext = MgnlContext.getInstance();
109         }
110         try{
111 
112             if (parName.startsWith(WorkflowConstants.PARTICIPANT_PREFIX_COMMAND)){
113                 log.debug("Consuming command {}...", parName);
114 
115                 try {
116                     String name = StringUtils.removeStart(parName, WorkflowConstants.PARTICIPANT_PREFIX_COMMAND);
117                     Command c = CommandsManager.getInstance().getCommand(name);
118                     if (c != null) {
119                         log.debug("Command has been found through the magnolia catalog: {}", c.getClass().getName());
120 
121                         // set parameters in the context
122                         // precise what we're talking about here: this is forced to be a System Context :
123                         // since we are processing within the workflow enviroment
124                         Context context = new WorkItemContext(MgnlContext.getSystemContext(), wi);
125 
126                         // remember to reset it after execution
127                         MgnlContext.setInstance(context);
128 
129                         // execute
130                         c.execute(context);
131 
132                         WorkflowModule.getEngine().reply((InFlowWorkItem) wi);
133 
134                     }
135                     else {
136                         // not found, do in the old ways
137                         log.error("No command has been found through the magnolia catalog for name: {}", parName);
138                     }
139 
140                     log.debug("Consumed command {}.", parName);
141                 }
142                 catch (Exception e) {
143                     log.error("Couldn't consume command " + parName, e);
144                 }
145             }
146             else {
147                 MgnlContext.setInstance(MgnlContext.getSystemContext());
148                 WorkflowUtil.getWorkItemStore().storeWorkItem(StringUtils.EMPTY, (InFlowWorkItem) wi);
149             }
150         }
151         finally {
152             MgnlContext.release();
153             MgnlContext.setInstance(originalContext);
154         }
155 
156         log.debug("Finished consume()..");
157 
158     }
159 }