001: package de.webman.content.workflow;
002:
003: import java.util.Date;
004: import java.util.Vector;
005: import java.util.Hashtable;
006: import java.util.Enumeration;
007:
008: import com.teamkonzept.lib.TKHashtable;
009: import com.teamkonzept.lib.TKHashable;
010: import com.teamkonzept.web.TKEvent;
011: import de.webman.acl.*;
012: import com.teamkonzept.webman.mainint.ContextConstants;
013: import com.teamkonzept.lib.TKException;
014: import de.webman.content.workflow.db.*;
015: import java.text.SimpleDateFormat;
016: import de.webman.content.attributs.AttributeHandler;
017:
018: import org.apache.log4j.Category;
019:
020: /**
021: Huelle fuer Contentversion in Webman
022:
023: * @author $Author: sebastian $
024: * @version $Revision: 1.14 $
025: */
026:
027: public class ContentVersion implements TKHashable {
028: /** Logging Category */
029: private static final Category CAT = Category
030: .getInstance(ContentVersion.class);
031:
032: /** Zum formatieren des Datums einer Version */
033: private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat(
034: "dd.MM.yy HH:mm");
035:
036: /** Version Id */
037: private Integer id;
038:
039: /** Autor der Version */
040: private String author;
041:
042: /** Erstellungsdatum der Version */
043: private java.util.Date date;
044:
045: /** ID des wirklichen Contents*/
046: private Integer contentId;
047:
048: /** Workflowstatus der Version */
049: private VersionStatus status;
050:
051: /** im Workflow interessant ? */
052: private boolean isInteresting;
053:
054: /** sind wir in einem Single Content ?*/
055: private boolean isSingle;
056:
057: /** ID des uebergeordneten Contents */
058: private Integer contentNodeId;
059:
060: /** gecached die Hashtable */
061: private TKHashtable templateData = null;
062:
063: /** cache der Contentattribute */
064: private AttributeHandler attr = null;
065:
066: /** enthählt den Klassennamen des Attributes, welches ein generieren der CV
067: beim letzten Aufruf von isGeneratable verhindert hat */
068: private String generatableVersionStatus = null;
069:
070: /** lädt falls nötig die Attribute*/
071: private void initAttributes() {
072: if (attr == null)
073: attr = new AttributeHandler(getContentId());
074: }
075:
076: /** hat die aktuelle CV Attribute ?
077: @return true if there are Attributes - false otherwise */
078: private boolean hasAttributes() {
079: initAttributes();
080: return !attr.isEmpty();
081: }
082:
083: public ContentVersion(Integer _id, Integer _contentId,
084: Integer _contentNodeId, String _author,
085: java.util.Date _date, VersionStatus _status, boolean single) {
086: id = _id;
087: contentId = _contentId;
088: contentNodeId = _contentNodeId;
089: author = _author;
090: date = _date;
091: status = _status;
092: isSingle = single;
093: }
094:
095: /**
096: gibt null zurück, falls beim letzten Aufruf von isGeneratable
097: keine Version aufgrund des Workflows zurückgegeben wurde.
098: Sonst den Klassennamen des Attributes, daß ein generieren der Contentversion
099: verhindert hat.
100: */
101: public String getGeneratableVersionStatus() {
102: return generatableVersionStatus;
103: }
104:
105: /**
106: ermittelt die erlaubte Transitionen dieser Version
107: es wird KEINE Ruecksicht darauf genommen, ob es spaetere Versionen gibt
108: ueberprueft NICHT die Userrechte !!
109: @return Hashtable der erlaubten Transitionen
110: */
111: public TKHashtable getTransitions()
112: {
113: TKHashtable back = new TKHashtable();
114: TKHashtable transitions = VersionStatics.getStatics().getTransitions();
115:
116: TKHashtable trans = (TKHashtable)transitions.get(new Integer(status.status_id));
117: Enumeration enum = trans.keys();
118: while (enum.hasMoreElements())
119: {
120: Object key = enum.nextElement();
121: VersionStatusTransitionDBData transData =
122: (VersionStatusTransitionDBData) trans.get(key);
123: if (transData.isTransition())
124: {
125: if (isSingle)
126: {
127: if (transData.toStatus.single)
128: back.put(key, transData);
129: }
130: else
131: back.put(key, transData);
132: }
133: }
134:
135: return back;
136: }
137:
138: /**
139: ermittelt die erlaubte Transitionen dieser Version
140: es wird KEINE Ruecksicht darauf genommen, ob es spaetere Versionen gibt
141: ueberprueft gleichzeitig die Userrechte !!
142: @return Hashtable der erlaubten Transitionen
143: */
144: public TKHashtable getAllowedTransitions()
145: {
146: // aktuellen Event bekommen
147: TKEvent evt = TKEvent.getEventForThread();
148: LoginFactory factory = null;
149: Login login = null;
150: TKHashtable back = new TKHashtable();
151:
152: // Userfactories erhalten
153: try
154: {
155: factory = LoginFactory.getInstance();
156: login = factory.getLogin(evt.getRemoteUser());
157: TKHashtable transitions = VersionStatics.getStatics().getTransitions();
158:
159: TKHashtable trans = (TKHashtable)transitions.get(new Integer(status.status_id));
160: Enumeration enum = trans.keys();
161: while (enum.hasMoreElements())
162: {
163: Object key = enum.nextElement();
164: VersionStatusTransitionDBData transData =
165: (VersionStatusTransitionDBData) trans.get(key);
166: if (transData.isTransition())
167: {
168: // jetzt den Event überprüfen
169: Event event = EventFactory.getInstance().getEvent(transData.getEvent());
170: // was ist, wenn event null ist?
171: if ((event == null) || (!login.isAllowed(event.getID(), ContextConstants.CONTENT_EDIT, Policy.CONTENT_TREE_ID, contentNodeId)))
172: {
173: CAT.debug("Nicht erlaubt : " + transData.getEvent());
174: }
175: else
176: {
177: // Single Zustaende pruefen
178: if (isSingle)
179: {
180: if (transData.toStatus.single)
181: back.put(key, transData);
182: }
183: else
184: {
185: back.put(key, transData);
186: }
187: }
188: }
189: }
190: }
191: catch (TKException e)
192: {
193: CAT.error("Error in getAllowed Transitions", e);
194: }
195:
196: return back;
197: }
198:
199: /** returns the CV-ID
200: @return id der ContentVersion */
201: public Integer getId() {
202: return id;
203: }
204:
205: /** @return id des eigendlichen Contents */
206: public Integer getContentId() {
207: return contentId;
208: }
209:
210: /** checks whether the current Version isGeneratable by workflow and
211: contentattributes
212: @return boolean - true if Version is generatable otherwise false;
213: if false @see getGeneratableVersionStatus for more details*/
214: public boolean isGeneratable() {
215: if (status.generate) {
216: initAttributes();
217:
218: generatableVersionStatus = attr.getGeneratableStatus(null);
219: if (generatableVersionStatus == null)
220: return true;
221: else
222: return false;
223: }
224: return status.generate;
225: }
226:
227: public boolean isInteresting() {
228: return isInteresting;
229: }
230:
231: public String getAuthor() {
232: return author;
233: }
234:
235: public java.util.Date getDate() {
236: return date;
237: }
238:
239: public VersionStatus getStatus() {
240: return status;
241: }
242:
243: public TKHashtable toHashtable() {
244: if (templateData != null)
245: return templateData;
246: templateData = new TKHashtable();
247: templateData.put("VERSION_ID", id);
248: templateData.put("AUTHOR", author);
249: String formattedDate = DATE_FORMAT.format(date);
250: templateData.put("DATE", formattedDate);
251: templateData.put("STATUS_DEF", status); // hier muss wohl noch weiter aufbereitet werden
252:
253: templateData.put("HAS_ATTR", hasAttributes() ? "TRUE" : "");
254: // unter TRANSITIONS alle moeglichen Uebergaenge ablegen
255: templateData.put("TRANSITIONS", getAllowedTransitions());
256:
257: /* abfrage ob der Content nach seinen Attributen gültig ist */
258: AttributeHandler attr = new AttributeHandler(contentId);
259: if (attr.getGeneratableStatus(null) == null)
260: templateData.put("VALID", "1");
261:
262: return templateData;
263: }
264:
265: public String toString() {
266: String text = " ContentVersion Id : " + id;
267: text += " Content : " + contentId;
268: return text;
269: }
270: }
|