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

   1 package org.splat.simer;
   2
   3 import java.io.File;
   4 import java.io.FileNotFoundException;
   5 import java.text.SimpleDateFormat;
   6 import java.util.ArrayList;
   7 import java.util.Arrays;
   8 import java.util.Date;
   9 import java.util.List;
  10 import java.util.ResourceBundle;
  11
  12 import org.splat.dal.bo.kernel.User;
  13 import org.splat.dal.bo.som.Document;
  14 import org.splat.dal.bo.som.DocumentType;
  15 import org.splat.dal.bo.som.ProgressState;
  16 import org.splat.dal.bo.som.Publication;
  17 import org.splat.dal.bo.som.ValidationCycle;
  18 import org.splat.dal.bo.som.ValidationStep;
  19 import org.splat.manox.Reader;
  20 import org.splat.manox.Toolbox;
  21 import org.splat.service.DocumentService;
  22 import org.splat.service.DocumentTypeService;
  23 import org.splat.som.Revision;
  24 import org.splat.som.Step;
  25 import org.splat.wapp.Constants;
  26
  27 /**
  28  * Action for adding a document into a study step.
  29  */
  30 public class ImportDocumentAction extends BaseUploadDocumentAction {
  31
  32         /**
  33          * Serial version ID.
  34          */
  35         private static final long serialVersionUID = 2587822564883588556L;
  36
  37         /**
  38          * Sorted list of document types for the selected study step.
  39          */
  40         private transient List<DocumentType> _documentTypes = null;
  41         /**
  42          * Sorted list of document types for the selected study step.
  43          */
  44         private transient final List<Boolean> _reviewable = new ArrayList<Boolean>();
  45         /**
  46          * The selected document type.
  47          */
  48         private long _documentType = 0;
  49         /**
  50          * Reference extracted from the imported file, if exist.
  51          */
  52         private String _reference = null;
  53         /**
  54          * Injected document service.
  55          */
  56         private DocumentService _documentService;
  57         /**
  58          * Injected document type service.
  59          */
  60         private DocumentTypeService _documentTypeService;
  61
  62         /**
  63          * Initialize the operation.
  64          *
  65          * @return SUCCESS in success, otherwise - ERROR
  66          */
  67         public String doInitialize() {
  68
  69                 File upfile = commonInitialize(Constants.FALSE);
  70                 String[] table = _fileName.split("\\x2E");
  71                 String filext = table[table.length - 1].toLowerCase();
  72
  73                 _mystudy = getOpenStudy();
  74                 Step step = _mystudy.getSelectedStep();
  75                 _documentTypes = getStepService().getValidDocumentTypes(step);
  76                 // Set the document type by default
  77                 _deftype = getApplicationSettings()
  78                                 .getDefaultDocumentType(step, filext);
  79                 if (_deftype != null) {
  80                         setDefaultDocumentType(_deftype.getIndex());
  81                 }
  82                 _defuses = new ArrayList<Document>();
  83                 _state = ProgressState.inWORK;
  84
  85                 String res = ERROR;
  86                 if (extractProperties(upfile, filext)) {
  87                         if (_docname == null) {
  88                                 _docname = table[0];
  89                                 for (int i = 1; i < table.length - 1; i++) {
  90                                         _docname = _docname + "." + table[i];
  91                                 }
  92                         }
  93                         if (_deftype != null) {
  94                                 setupDefaultUses(_deftype);
  95                         }
  96
  97                         DocumentType[] types = _documentTypes
  98                                         .toArray(new DocumentType[_documentTypes.size()]);
  99                         DocumentTypeComparator compare = new DocumentTypeComparator();
 100                         Arrays.sort(types, compare);
 101                         _documentTypes = Arrays.asList(types);
 102                         res = SUCCESS;
 103                 }
 104
 105                 // Initialize isReviewable: if a type has review state or not
 106                 ValidationCycle cycle;
 107                 boolean hasReview;
 108                 for (DocumentType dtype : _documentTypes) {
 109                         cycle = getStudyService().getValidationCycleOf(
 110                                         _mystudy.getMystudy(), dtype);
 111                         hasReview = (cycle != null) && cycle.enables(ValidationStep.REVIEW);
 112                         _reviewable.add(hasReview);
 113                 }
 114                 return res;
 115         }
 116
 117         /**
 118          * Extract properties from the uploaded file.
 119          *
 120          * @param upfile
 121          *            the file to parse
 122          * @param filext
 123          *            the file extension
 124          * @return true if succeeded, false if error
 125          */
 126         private boolean extractProperties(final File upfile, final String filext) {
 127                 boolean isOk = true;
 128                 Reader tool = Toolbox.getReader(upfile);
 129                 if (tool == null) {
 130                         if ("pdf".equals(filext)) {
 131                                 _state = ProgressState.EXTERN; // TODO: Should external extensions be configurable ?
 132                         }
 133                 } else {
 134                         // String fileref = tool.extractProperty("reference");
 135                         // String filever = tool.extractProperty("version"); // Property kept even if the file is not referenced
 136                         // String filetype = tool.extractProperty("type"); // Property kept even if the file is not referenced
 137                         // for (Iterator<DocumentType> i = _documentTypes.iterator(); i
 138                         // .hasNext();) {
 139                         // DocumentType type = i.next();
 140                         // if (type.getName().equals(filetype)) {
 141                         // _deftype = type;
 142                         // _documentType = type.getIndex(); // Disables the document type field
 143                         // break;
 144                         // }
 145                         // }
 146                         // if (fileref != null) {
 147                         // isOk = findTypeByDocRef(fileref);
 148                         // }
 149                         // if (isOk) {
 150                         // if (filever != null) {
 151                         // try {
 152                         // Revision.Format get = new Revision.Format(
 153                         // getProjectSettings().getRevisionPattern());
 154                         // Revision version = get.parse(filever);
 155                         // if (version.isNull()) {
 156                         // throw new ParseException(filever,
 157                         // filever.length() - 1);
 158                         // }
 159                         // if (!version.isMinor()) {
 160                         // _state = ProgressState.inCHECK;
 161                         // }
 162                         // setVersion(version.toString());
 163                         // } catch (ParseException e) {
 164                         // setErrorCode("message.error.format.version");
 165                         // isOk = false;
 166                         // }
 167                         // }
 168                         // if (isOk) {
 169                         // _docname = tool.extractProperty("title"); // Property kept even if the file is not referenced
 170                         // isOk = extractDate(tool);
 171                         // }
 172                         // }
 173                 }
 174                 return isOk;
 175         }
 176
 177         /**
 178          * Find document type by document reference.
 179          *
 180          * @param fileref
 181          *            the document reference
 182          * @return true if succeeded, false if error
 183          */
 184         private boolean findTypeByDocRef(final String fileref) {
 185                 boolean isOk = true;
 186                 Document slot = getDocumentService().selectDocument(fileref,
 187                                 new Revision().toString());
 188                 if (slot == null) {
 189                         setError("message.error.reference.undefined");
 190                         isOk = false;
 191                 } else {
 192                         if (slot.isUndefined()) {
 193                                 _reference = fileref; // Disables document name and state fields
 194                                 _deftype = slot.getType(); // Just in case
 195                                 _documentType = _deftype.getIndex(); // Disables the document type field
 196                         } else {
 197                                 setError("message.error.reference.duplicate");
 198                                 isOk = false;
 199                         }
 200                 }
 201                 return isOk;
 202         }
 203
 204         /**
 205          * Perform import of a document.
 206          *
 207          * @return SUCCESS if ok, "cancel" - if canceled, ERROR - if error
 208          */
 209         public String doImport() {
 210                 String res = ERROR;
 211
 212                 initializationScreenContext(Constants.STUDY_MENU, Constants.STUDY_MENU,
 213                                 Constants.TRUE);
 214
 215                 if (_action == ToDo.cancel) {
 216                         res = "cancel";
 217                 } else if (_documentType == 0) {
 218                         setErrorCode("message.error.import.type");
 219
 220                         initializationFullScreenContext(Constants.STUDY_MENU,
 221                                         Constants.STUDY_MENU, Constants.TRUE, Constants.NONE,
 222                                         Constants.STUDY_MENU);
 223                 } else {
 224                         try {
 225                                 // Getting user inputs
 226                                 _mystudy = getOpenStudy();
 227                                 User user = getConnectedUser();
 228                                 Step step = _mystudy.getSelectedStep();
 229                                 Date aDate = null;
 230                                 if (getDocumentDate().length() > 0) {
 231                                         ResourceBundle locale = ResourceBundle.getBundle("som",
 232                                                         getApplicationSettings().getCurrentLocale());
 233                                         SimpleDateFormat get = new SimpleDateFormat(locale
 234                                                         .getString("date.format"), getApplicationSettings()
 235                                                         .getCurrentLocale());
 236                                         aDate = get.parse(getDocumentDate());
 237                                 }
 238                                 // Creation of uses relations
 239                                 List<Long> uses = new ArrayList<Long>();
 240                                 if (_docuses != null) {
 241                                         String[] list = _docuses.split(",");
 242                                         for (int i = 0; i < list.length; i++) {
 243                                                 uses.add(Long.valueOf(list[i].trim()));
 244                                         }
 245                                 }
 246                                 if (LOG.isDebugEnabled()) {
 247                                         LOG
 248                                                         .debug("Document to be imported uses documents with following ids:");
 249                                         for (Long usesId : uses) {
 250                                                 LOG.debug("#" + usesId);
 251                                         }
 252                                 }
 253                                 Publication addoc = getPublicationService().createDoc(
 254                                                 _mystudy.getIndex(), step, _documentType,
 255                                                 user.getIndex(), _fileName, _docname, _state,
 256                                                 _reference, getVersion(), aDate, uses);
 257
 258                                 if (_reference.length() > 0) { // Importation of a not foreign document
 259                                         _mystudy.updateSimulationContexts(); // In case of simulation contexts extracted from the imported document
 260                                 }
 261
 262                                 // Creation of derived the document formats
 263                                 // Document ndoc = addoc.value();
 264                                 // Converter send = getApplicationSettings().getConverter(ndoc.getType(), ndoc.getFormat());
 265                                 //
 266                                 // if (send != null) send.converts(addoc); // Asynchronous process
 267
 268                                 if (uses.isEmpty()) {
 269                                         _mystudy.add(addoc); // Updates the presentation
 270                                 } else {
 271                                         // Re-opening (refreshing) the currently open study
 272                                         String selection = _mystudy.getSelection();
 273                                         _mystudy = open(getStudyService().selectStudy(
 274                                                         _mystudy.getIndex())); // Updates the study
 275                                         _mystudy.setSelection(selection);
 276                                 }
 277                                 res = SUCCESS;
 278                         } catch (FileNotFoundException error) {
 279                                 LOG.error("Reason:", error);
 280                                 setErrorCode("message.error.import.file");
 281                         } catch (Exception error) {
 282                                 LOG.error("Reason:", error);
 283                                 setErrorCode("message.error.internal");
 284                         }
 285
 286                         if (!SUCCESS.equals(res)) {
 287                                 initializationFullScreenContext(Constants.STUDY_MENU,
 288                                                 Constants.STUDY_MENU, Constants.TRUE, Constants.NONE,
 289                                                 Constants.STUDY_MENU);
 290                         }
 291                 }
 292
 293                 return res;
 294         }
 295
 296         // ==============================================================================================================================
 297         // Getters and setters
 298         // ==============================================================================================================================
 299
 300         /**
 301          * Get sorted list of document types valid for the selected study step.
 302          *
 303          * @return sorted list of document types
 304          */
 305         public List<DocumentType> getDocumentTypes() {
 306                 return _documentTypes;
 307         }
 308
 309         /**
 310          * Get document type id.
 311          *
 312          * @return document type id
 313          */
 314         public long getDocumentType() {
 315                 return _documentType;
 316         }
 317
 318         /**
 319          * Get reference extracted from the imported file, if exist.
 320          *
 321          * @return the document reference
 322          */
 323         public String getReference() {
 324                 return _reference;
 325         }
 326
 327         /**
 328          * Set document name entered by the user if enabled.
 329          *
 330          * @param name
 331          *            the document name
 332          */
 333         public void setDocumentName(final String name) {
 334                 this._docname = name; // Name entered by the user if enabled
 335         }
 336
 337         /**
 338          * Set the default title if no title was defined.
 339          *
 340          * @param name
 341          *            the default document title
 342          */
 343         public void setDocumentTitle(final String name) { // Called even if DocumentName is enabled
 344                 if (this._docname == null) {
 345                         this._docname = name;
 346                 }
 347         }
 348
 349         /**
 350          * Set document type id.
 351          *
 352          * @param value
 353          *            the id as string
 354          */
 355         public void setDocumentType(final Long value) {
 356                 this._documentType = value;
 357         }
 358
 359         /**
 360          * Set the default state if no state was selected.
 361          *
 362          * @param state
 363          *            the default state
 364          */
 365         public void setDefaultDocumentState(final String state) { // Called even if DocumentState is enabled
 366                 if (this._state == null) {
 367                         this._state = ProgressState.valueOf(state);
 368                 }
 369         }
 370
 371         /**
 372          * Set the default type if no type was selected.
 373          *
 374          * @param value
 375          *            the default document type id
 376          */
 377         public void setDefaultDocumentType(final Long value) { // Called even if DocumentType is enabled
 378                 if (this._documentType == 0) {
 379                         this._documentType = value;
 380                 }
 381         }
 382
 383         /**
 384          * Set document reference extracted from the imported file, if exist.
 385          *
 386          * @param value
 387          *            the reference
 388          */
 389         public void setReference(final String value) {
 390                 this._reference = value;
 391         }
 392
 393         /**
 394          * Get the documentService.
 395          *
 396          * @return the documentService
 397          */
 398         public DocumentService getDocumentService() {
 399                 return _documentService;
 400         }
 401
 402         /**
 403          * Set the documentService.
 404          *
 405          * @param documentService
 406          *            the documentService to set
 407          */
 408         public void setDocumentService(final DocumentService documentService) {
 409                 _documentService = documentService;
 410         }
 411
 412         /**
 413          * Get the documentTypeService.
 414          *
 415          * @return the documentTypeService
 416          */
 417         public DocumentTypeService getDocumentTypeService() {
 418                 return _documentTypeService;
 419         }
 420
 421         /**
 422          * Set the documentTypeService.
 423          *
 424          * @param documentTypeService
 425          *            the documentTypeService to set
 426          */
 427         public void setDocumentTypeService(
 428                         final DocumentTypeService documentTypeService) {
 429                 _documentTypeService = documentTypeService;
 430         }
 431
 432         /**
 433          * Get sorted list of available document states.
 434          *
 435          * @return the documentStates
 436          */
 437         public List<ProgressState> getDocumentStates() {
 438                 List<ProgressState> states = new ArrayList<ProgressState>();
 439                 states.add(ProgressState.inWORK);
 440                 states.add(ProgressState.inDRAFT);
 441                 states.add(ProgressState.EXTERN);
 442                 return states;
 443         }
 444
 445         /**
 446          * Get the isReviewable.
 447          *
 448          * @return the isReviewable
 449          */
 450         public List<Boolean> getReviewable() {
 451                 return _reviewable;
 452         }
 453 }