Workspace/Siman/src/org/splat/simer/OpenObject.java

   1 package org.splat.simer;
   2
   3 import java.util.HashMap;
   4 import java.util.Iterator;
   5 import java.util.List;
   6 import java.util.Vector;
   7
   8 import org.splat.dal.bo.kernel.User;
   9 import org.splat.dal.bo.som.Document;
  10 import org.splat.dal.bo.som.DocumentType;
  11 import org.splat.dal.bo.som.KnowledgeElement;
  12 import org.splat.dal.bo.som.KnowledgeElementType;
  13 import org.splat.dal.bo.som.ProgressState;
  14 import org.splat.service.KnowledgeElementService;
  15 import org.splat.service.KnowledgeElementTypeService;
  16 import org.splat.service.ProjectElementService;
  17 import org.splat.service.PublicationService;
  18 import org.splat.service.dto.Proxy;
  19 import org.splat.service.technical.ProjectSettingsService;
  20 import org.splat.dal.bo.som.Publication;
  21 import org.splat.dal.bo.som.Scenario;
  22 import org.splat.som.Step;
  23 import org.splat.wapp.Menu;
  24 import org.splat.wapp.PopupMenu;
  25
  26 public abstract class OpenObject implements Proxy {
  27
  28         protected static HashMap<Long, DocumentFacade> docpres = null;
  29         protected static HashMap<Long, KnowledgeElementFacade> knowpres = null;
  30
  31         protected User cuser = null; // Connected user
  32         protected String selection = null; // Menu selected by the user
  33         protected Step ustep = null; // Corresponding selected step
  34         protected String description = null; // Object description (rich text)
  35         protected List<Step> involving = null;
  36         protected List<SimulationContextFacade> context = null; // Simulation Context display representations
  37         protected List<DocumentFacade> contents = null; // Document display representations
  38         protected List<KnowledgeIterator> knowledge = null; // Knowledge Element display representations structured by knowledge types
  39
  40         protected Menu menu = null; // Left pane menu of this object
  41         protected PopupMenu popup = null; // Pop-up menu of this object, if the user has write access
  42         /**
  43          * Injected project settings service.
  44          */
  45         private ProjectSettingsService _projectSettingsService;
  46         /**
  47          * Injected publication service.
  48          */
  49         private PublicationService _publicationService;
  50         /**
  51          * Injected knowledge element service.
  52          */
  53         private KnowledgeElementTypeService _knowledgeElementTypeService;
  54         /**
  55          * Injected project element service.
  56          */
  57         private ProjectElementService _projectElementService;
  58
  59         public class KnowledgeIterator {
  60                 protected KnowledgeElementType type;
  61                 protected List<KnowledgeElementFacade> list;
  62
  63                 public KnowledgeIterator(KnowledgeElementType type,
  64                                 List<KnowledgeElementFacade> list) {
  65                         this.type = type;
  66                         this.list = list;
  67                 }
  68
  69                 public String getIndex() {
  70                         return String.valueOf(type.getIndex());
  71                 }
  72
  73                 public String getType() {
  74                         return type.getName();
  75                 }
  76
  77                 public List<KnowledgeElementFacade> getKnowledgeElements() {
  78                         return list;
  79                 }
  80         }
  81
  82         // ==============================================================================================================================
  83         // Constructor
  84         // ==============================================================================================================================
  85
  86         protected OpenObject() {
  87                 // -----------------------
  88                 // All member fields are supposed initialized by subclasses
  89                 if (docpres == null)
  90                         docpres = new HashMap<Long, DocumentFacade>();
  91                 if (knowpres == null)
  92                         knowpres = new HashMap<Long, KnowledgeElementFacade>();
  93         }
  94
  95         // ==============================================================================================================================
  96         // Public member functions
  97         // ==============================================================================================================================
  98
  99         public void developDocument(String index) {
 100                 // ------------------------------------------
 101                 for (Iterator<DocumentFacade> i = contents.iterator(); i.hasNext();) {
 102                         DocumentFacade doc = i.next();
 103                         if (!doc.getIndex().equals(index))
 104                                 continue;
 105                         doc.develop();
 106                         return;
 107                 }
 108         }
 109
 110         public void developKnowledge(String index) {
 111                 // -------------------------------------------
 112                 for (Iterator<KnowledgeIterator> i = knowledge.iterator(); i.hasNext();) {
 113                         List<KnowledgeElementFacade> knowelms = i.next()
 114                                         .getKnowledgeElements();
 115                         for (Iterator<KnowledgeElementFacade> j = knowelms.iterator(); j
 116                                         .hasNext();) {
 117                                 KnowledgeElementFacade kelm = j.next();
 118                                 if (!kelm.getIndex().equals(index))
 119                                         continue;
 120                                 kelm.develop();
 121                                 return;
 122                         }
 123                 }
 124         }
 125
 126         public void clearFacades() {
 127                 // ---------------------------
 128                 docpres.clear(); // For eventually reopening the knowledge from a fresh context
 129                 knowpres.clear(); // For eventually reopening the knowledge from a fresh context
 130         }
 131
 132         public List<Document> collectInvolvedDocuments(DocumentType type) {
 133                 // ------------------------------------------------------------------
 134                 List<Document> found = new Vector<Document>();
 135                 for (Iterator<Step> i = involving.iterator(); i.hasNext();) {
 136                         Step step = i.next();
 137                         List<Publication> exist = step.getAllDocuments();
 138                         for (Iterator<Publication> j = exist.iterator(); j.hasNext();) {
 139                                 Document doc = j.next().value();
 140                                 if (doc.getType().equals(type))
 141                                         found.add(doc);
 142                         }
 143                 }
 144                 return found;
 145         }
 146
 147         public String getDisplayedDescription() {
 148                 // ----------------------------------------
 149                 return description;
 150         }
 151
 152         public List<DocumentFacade> getDisplayedDocuments() {
 153                 // -----------------------------------------------------
 154                 return contents;
 155         }
 156
 157         public List<SimulationContextFacade> getDisplayedSimulationContexts() {
 158                 // ----------------------------------------------------------------------
 159                 return context;
 160         }
 161
 162         public List<KnowledgeIterator> getDisplayedKnowledges() {
 163                 // --------------------------------------------------------
 164                 return knowledge;
 165         }
 166
 167         public List<Step> getInvolvedSteps() {
 168                 // -------------------------------------
 169                 return involving;
 170         }
 171
 172         public Menu getMenu() {
 173                 // ----------------------
 174                 return menu;
 175         }
 176
 177         public PopupMenu getPopup() {
 178                 // ----------------------------
 179                 return popup;
 180         }
 181
 182         public Step getSelectedStep() {
 183                 // ------------------------------
 184                 return ustep;
 185         }
 186
 187         public String getSelection() {
 188                 // -----------------------------
 189                 return selection;
 190         }
 191
 192         public User getUser() {
 193                 // ----------------------
 194                 return cuser;
 195         }
 196
 197         public boolean isOpenForWriting() {
 198                 // ----------------------------------
 199                 return (popup != null); // The pop-up is supposed existed when the user is staffed on the study
 200         }
 201
 202         public void reduceDocument(String index) {
 203                 // -----------------------------------------
 204                 for (Iterator<DocumentFacade> i = contents.iterator(); i.hasNext();) {
 205                         DocumentFacade doc = i.next();
 206                         if (!doc.getIndex().equals(index))
 207                                 continue;
 208                         doc.reduceAll();
 209                         return;
 210                 }
 211         }
 212
 213         public void reduceHistory(String index) {
 214                 // ----------------------------------------
 215                 for (Iterator<DocumentFacade> i = contents.iterator(); i.hasNext();) {
 216                         DocumentFacade doc = i.next();
 217                         if (!doc.getIndex().equals(index))
 218                                 continue;
 219                         doc.reduce();
 220                         return;
 221                 }
 222         }
 223
 224         public void reduceKnowledge(String index) {
 225                 // ------------------------------------------
 226                 for (Iterator<KnowledgeIterator> i = knowledge.iterator(); i.hasNext();) {
 227                         List<KnowledgeElementFacade> knowelms = i.next()
 228                                         .getKnowledgeElements();
 229                         for (Iterator<KnowledgeElementFacade> j = knowelms.iterator(); j
 230                                         .hasNext();) {
 231                                 KnowledgeElementFacade kelm = j.next();
 232                                 if (!kelm.getIndex().equals(index))
 233                                         continue;
 234                                 kelm.reduce();
 235                                 return;
 236                         }
 237                 }
 238         }
 239
 240         // ==============================================================================================================================
 241         // Protected services
 242         // ==============================================================================================================================
 243
 244         protected void setupContents() {
 245                 // -------------------------------
 246                 // Description
 247                 // Initialized in subclasses
 248
 249                 // Knowledge elements supposed ordered by type
 250                 if (ustep.mayContain(KnowledgeElement.class)) {
 251                         Scenario scene = (Scenario) ustep.getOwner();
 252                         List<KnowledgeElementType> types = getKnowledgeElementTypeService()
 253                                         .selectTypesWhere(ProgressState.APPROVED);
 254                         List<KnowledgeElement> kelms = scene.getAllKnowledgeElements();
 255                         Iterator<KnowledgeElement> more = kelms.iterator();
 256                         KnowledgeElement current = null;
 257                         if (more.hasNext())
 258                                 current = more.next();
 259
 260                         knowledge = new Vector<KnowledgeIterator>(types.size());
 261                         for (Iterator<KnowledgeElementType> i = types.iterator(); i
 262                                         .hasNext();) {
 263                                 KnowledgeElementType type = i.next();
 264                                 List<KnowledgeElementFacade> display = new Vector<KnowledgeElementFacade>(
 265                                                 kelms.size());
 266                                 while (current != null && current.getType().equals(type)) {
 267                                         KnowledgeElementFacade facade = knowpres.get(current
 268                                                         .getIndex());
 269                                         if (facade == null) {
 270                                                 facade = new KnowledgeElementFacade(current);
 271                                                 knowpres.put(current.getIndex(), facade);
 272                                         }
 273                                         display.add(facade);
 274                                         if (more.hasNext())
 275                                                 current = more.next();
 276                                         else
 277                                                 current = null;
 278                                 }
 279                                 knowledge.add(new KnowledgeIterator(type, display));
 280                         }
 281                 } else {
 282                         knowledge = null;
 283                 }
 284                 // Documents
 285                 if (ustep.mayContain(Document.class)) {
 286                         List<Publication> list = ustep.getAllDocuments();
 287
 288                         contents = new Vector<DocumentFacade>(list.size());
 289                         for (Iterator<Publication> i = list.iterator(); i.hasNext();) {
 290                                 Publication present = i.next();
 291                                 Long index = present.getIndex();
 292                                 DocumentFacade facade = docpres.get(index);
 293                                 if (facade == null) {
 294                                         facade = new DocumentFacade(this, present,
 295                                                         getProjectSettings(), getPublicationService());
 296                                         docpres.put(index, facade);
 297                                 }
 298                                 contents.add(facade);
 299                         }
 300                 } else {
 301                         contents = null;
 302                 }
 303         }
 304
 305         /**
 306          * Get project settings.
 307          *
 308          * @return Project settings service
 309          */
 310         public ProjectSettingsService getProjectSettings() {
 311                 return _projectSettingsService;
 312         }
 313
 314         /**
 315          * Get the publicationService.
 316          *
 317          * @return the publicationService
 318          */
 319         public PublicationService getPublicationService() {
 320                 return _publicationService;
 321         }
 322
 323         /**
 324          * Set project settings service.
 325          *
 326          * @param projectSettingsService
 327          *            project settings service
 328          */
 329         public void setProjectSettings(ProjectSettingsService projectSettingsService) {
 330                 _projectSettingsService = projectSettingsService;
 331         }
 332
 333         /**
 334          * Set the publicationService.
 335          *
 336          * @param publicationService
 337          *            the publicationService to set
 338          */
 339         public void setPublicationService(PublicationService publicationService) {
 340                 _publicationService = publicationService;
 341         }
 342
 343         /**
 344          * Set the menu.
 345          *
 346          * @param menu
 347          *            the menu to set
 348          */
 349         public void setMenu(Menu menu) {
 350                 this.menu = menu;
 351         }
 352
 353         /**
 354          * Get the projectElementService.
 355          *
 356          * @return the projectElementService
 357          */
 358         public ProjectElementService getProjectElementService() {
 359                 return _projectElementService;
 360         }
 361
 362         /**
 363          * Set the projectElementService.
 364          *
 365          * @param projectElementService
 366          *            the projectElementService to set
 367          */
 368         public void setProjectElementService(
 369                         ProjectElementService projectElementService) {
 370                 _projectElementService = projectElementService;
 371         }
 372
 373         /**
 374          * Get the knowledgeElementTypeService.
 375          * @return the knowledgeElementTypeService
 376          */
 377         public KnowledgeElementTypeService getKnowledgeElementTypeService() {
 378                 return _knowledgeElementTypeService;
 379         }
 380
 381         /**
 382          * Set the knowledgeElementTypeService.
 383          * @param knowledgeElementTypeService the knowledgeElementTypeService to set
 384          */
 385         public void setKnowledgeElementTypeService(
 386                         KnowledgeElementTypeService knowledgeElementTypeService) {
 387                 _knowledgeElementTypeService = knowledgeElementTypeService;
 388         }
 389 }