eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/io/ImportManager.java

   1 /**
   2  * Copyright (C) 2007 EDIT
   3  * European Distributed Institute of Taxonomy
   4  * http://www.e-taxonomy.eu
   5  *
   6  * The contents of this file are subject to the Mozilla Public License Version 1.1
   7  * See LICENSE.TXT at the top of this package for the full license terms.
   8  */
   9
  10 package eu.etaxonomy.taxeditor.io;
  11
  12 import java.io.File;
  13 import java.io.InputStream;
  14 import java.nio.file.Files;
  15 import java.nio.file.Path;
  16 import java.nio.file.Paths;
  17 import java.util.List;
  18 import java.util.UUID;
  19
  20 import org.apache.commons.io.IOUtils;
  21 import org.apache.commons.lang.StringUtils;
  22 import org.eclipse.core.runtime.Assert;
  23 import org.eclipse.core.runtime.IProgressMonitor;
  24 import org.eclipse.core.runtime.IStatus;
  25 import org.eclipse.core.runtime.Status;
  26 import org.eclipse.core.runtime.jobs.Job;
  27 import org.eclipse.swt.widgets.Display;
  28 import org.eclipse.ui.PlatformUI;
  29
  30 import eu.etaxonomy.cdm.api.application.CdmApplicationState;
  31 import eu.etaxonomy.cdm.api.application.ICdmRepository;
  32 import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor;
  33 import eu.etaxonomy.cdm.io.common.CacheUpdaterConfigurator;
  34 import eu.etaxonomy.cdm.io.common.CdmDefaultImport;
  35 import eu.etaxonomy.cdm.io.common.IImportConfigurator;
  36 import eu.etaxonomy.cdm.io.common.IImportConfigurator.SOURCE_TYPE;
  37 import eu.etaxonomy.cdm.io.common.ImportConfiguratorBase;
  38 import eu.etaxonomy.cdm.io.common.ImportResult;
  39 import eu.etaxonomy.cdm.io.common.SortIndexUpdaterConfigurator;
  40 import eu.etaxonomy.cdm.io.distribution.excelupdate.ExcelDistributionUpdateConfigurator;
  41 import eu.etaxonomy.cdm.io.dwca.in.DwcaImportConfigurator;
  42 import eu.etaxonomy.cdm.io.excel.taxa.NormalExplicitImportConfigurator;
  43 import eu.etaxonomy.cdm.io.jaxb.JaxbImportConfigurator;
  44 import eu.etaxonomy.cdm.io.reference.endnote.in.EndnoteImportConfigurator;
  45 import eu.etaxonomy.cdm.io.sdd.in.SDDImportConfigurator;
  46 import eu.etaxonomy.cdm.io.service.IIOService;
  47 import eu.etaxonomy.cdm.io.specimen.abcd206.in.Abcd206ImportConfigurator;
  48 import eu.etaxonomy.cdm.io.specimen.excel.in.SpecimenCdmExcelImportConfigurator;
  49 import eu.etaxonomy.cdm.io.specimen.gbif.in.GbifImportConfigurator;
  50 import eu.etaxonomy.cdm.io.specimen.gbif.in.GbifImportState;
  51 import eu.etaxonomy.cdm.io.tcsxml.in.TcsXmlImportConfigurator;
  52 import eu.etaxonomy.taxeditor.model.AbstractUtility;
  53 import eu.etaxonomy.taxeditor.model.CdmProgressMonitorAdapter;
  54 import eu.etaxonomy.taxeditor.model.MessagingUtils;
  55 import eu.etaxonomy.taxeditor.operation.IPostMoniteredOperationEnabled;
  56 import eu.etaxonomy.taxeditor.store.CdmStore;
  57 import eu.etaxonomy.taxeditor.store.internal.TaxeditorStorePlugin;
  58 import eu.etaxonomy.taxeditor.ui.dialog.ReportTextDialog;
  59
  60 /**
  61  * <p>
  62  * ImportHandler class.
  63  * </p>
  64  *
  65  * @author n.hoffmann
  66  * @created Sep 11, 2009
  67  * @version 1.0
  68  */
  69 public class ImportManager extends AbstractIOManager<IImportConfigurator> implements IPostMoniteredOperationEnabled {
  70
  71         String importSuccessMessage = "The import was successfull.";
  72         String updateSuccessMessage = "The update was successfull.";
  73
  74         /**
  75          * @param applicationConfiguration
  76          */
  77         private ImportManager(ICdmRepository applicationConfiguration) {
  78                 super(applicationConfiguration);
  79         }
  80
  81         /**
  82          * <p>
  83          * NewInstance
  84          * </p>
  85          *
  86          * @param applicationConfiguration
  87          *            a
  88          *            {@link eu.etaxonomy.cdm.api.application.CdmApplicationController}
  89          *            object.
  90          * @return a {@link eu.etaxonomy.taxeditor.io.ImportManager} object.
  91          */
  92         public static ImportManager NewInstance(
  93                         ICdmRepository applicationConfiguration) {
  94                 return new ImportManager(applicationConfiguration);
  95         }
  96
  97         /**
  98          * Use when importing data into the current application context
  99          *
 100          * @param configurator
 101          *            a {@link eu.etaxonomy.cdm.io.common.IImportConfigurator}
 102          *            object.
 103          * @return a {@link org.eclipse.core.runtime.jobs.Job} object.
 104          */
 105         @Override
 106         protected Job createIOJob(final IImportConfigurator configurator) {
 107                 Assert.isNotNull(configurator, "Configuration may not be null");
 108
 109                 final Display display = Display.getDefault();
 110
 111                 Job job = new Job("Import: " + configurator.getClass().getSimpleName()) {
 112
 113                         @Override
 114                         protected IStatus run(IProgressMonitor monitor) {
 115                                 monitor.beginTask("Importing data", 100);
 116                                 configurator.setProgressMonitor(CdmProgressMonitorAdapter
 117                                                 .CreateSubMonitor(monitor, 70));
 118
 119                                 monitor.worked(5);
 120
 121                                 CdmDefaultImport<IImportConfigurator> importer = new CdmDefaultImport<IImportConfigurator>();
 122                                 importer.setCdmAppController(applicationConfiguration);
 123                                 monitor.worked(5);
 124                                 ImportResult importResult = null;
 125                                 try {
 126                                         importResult = importer.invoke(configurator);
 127
 128                                         monitor.worked(80);
 129                                 } catch (RuntimeException e) {
 130                                         MessagingUtils.messageDialog(
 131                                                         "Error importing data",
 132                                                         this,
 133                                                         "An error occured while"
 134                                                                         + "importing from source '"
 135                                                                         + configurator.getSourceNameString()
 136                                                                         + "'.\n"
 137                                                                         + "Please check error log for details.", e);
 138                                 }
 139
 140                                 monitor.worked(5);
 141                                 monitor.done();
 142
 143
 144                                 final StringBuilder reportText = new StringBuilder();
 145                                 if(importResult!=null){
 146                                     List<byte[]> reports = importResult.getReports();
 147                                     for (byte[] bs : reports) {
 148                         reportText.append(new String(bs));
 149                     }
 150                                 }
 151                                 display.asyncExec(new Runnable() {
 152
 153                                         @Override
 154                                         public void run() {
 155                         // display reports with possibility to save
 156                         ReportTextDialog dialog = new ReportTextDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell());
 157                         dialog.setTitle(configurator.getClass().getSimpleName()+" Report");
 158                         dialog.setReportText(reportText.toString());
 159                         dialog.open();
 160                                                 CdmStore.getContextManager().notifyContextRefresh();
 161                                         }
 162                                 });
 163
 164                                 return Status.OK_STATUS;
 165                         }
 166                 };
 167
 168                 return job;
 169
 170         }
 171
 172         public Job createIOServiceJob(IImportConfigurator configurator, InputStream is, SOURCE_TYPE type) {
 173
 174             try {
 175                 return createIOServiceJob(configurator, IOUtils.toByteArray(is), type);
 176             } catch (Exception e) {
 177                 MessagingUtils.errorDialog("Error importing input stream",
 178                         this,
 179                         e.getMessage(),
 180                         TaxeditorStorePlugin.PLUGIN_ID,
 181                         e,
 182                         true);
 183             }
 184             return null;
 185         }
 186
 187         public Job createIOServiceJob(IImportConfigurator configurator, File importFile, SOURCE_TYPE type) {
 188             Path path = Paths.get(importFile.toURI());
 189             try {
 190                 return createIOServiceJob(configurator, Files.readAllBytes(path), type);
 191             } catch (Exception e) {
 192                 MessagingUtils.errorDialog("Error importing file",
 193                         this,
 194                         e.getMessage(),
 195                         TaxeditorStorePlugin.PLUGIN_ID,
 196                         e,
 197                         true);
 198             }
 199             return null;
 200         }
 201
 202     public Job createIOServiceJob(final IImportConfigurator configurator, final byte[] data, final SOURCE_TYPE type) {
 203         Assert.isNotNull(configurator, "Configuration may not be null");
 204         final Display display = Display.getDefault();
 205         Job job = new Job("Import: " + configurator.getClass().getSimpleName()) {
 206
 207             @Override
 208             protected IStatus run(IProgressMonitor monitor) {
 209                 monitor.beginTask("Importing data", IProgressMonitor.UNKNOWN);
 210                 IIOService ioService = CdmApplicationState.getIOService();
 211
 212                 ImportResult result = ioService.importData(configurator, data, type);
 213
 214                 monitor.done();
 215
 216                 display.asyncExec(new Runnable() {
 217
 218                     @Override
 219                     public void run() {
 220                         CdmStore.getContextManager().notifyContextRefresh();
 221                     }
 222                 });
 223                 showResult(configurator.getClass().getSimpleName(), display, result, importSuccessMessage);
 224                 return Status.OK_STATUS;
 225             }
 226         };
 227
 228         return job;
 229
 230     }
 231
 232     public void runMoniteredOperation(IImportConfigurator configurator, InputStream is, SOURCE_TYPE type) {
 233
 234         try {
 235             runMoniteredOperation(configurator, IOUtils.toByteArray(is), type);
 236         } catch (Exception e) {
 237             MessagingUtils.errorDialog("Error importing input stream",
 238                     this,
 239                     e.getMessage(),
 240                     TaxeditorStorePlugin.PLUGIN_ID,
 241                     e,
 242                     true);
 243         }
 244
 245     }
 246
 247     public void runMoniteredOperation(IImportConfigurator configurator, SOURCE_TYPE type) {
 248         byte[] data = new byte[1];
 249         try {
 250             runMoniteredOperation(configurator, data, type);
 251         } catch (Exception e) {
 252             MessagingUtils.errorDialog("Error importing input stream",
 253                     this,
 254                     e.getMessage(),
 255                     TaxeditorStorePlugin.PLUGIN_ID,
 256                     e,
 257                     true);
 258         }
 259
 260     }
 261
 262     public void runMoniteredOperation(IImportConfigurator configurator, File importFile, SOURCE_TYPE type) {
 263         Path path = Paths.get(importFile.toURI());
 264         try {
 265             runMoniteredOperation(configurator, Files.readAllBytes(path), type);
 266
 267         } catch (Exception e) {
 268             MessagingUtils.errorDialog("Error importing input stream",
 269                     this,
 270                     e.getMessage(),
 271                     TaxeditorStorePlugin.PLUGIN_ID,
 272                     e,
 273                     true);
 274         }
 275
 276     }
 277
 278     public void runMoniteredOperation(final IImportConfigurator configurator, final byte[] data, final SOURCE_TYPE type) {
 279         IIOService ioService = CdmApplicationState.getIOService();
 280         final UUID uuid = ioService.monitImportData(configurator, data, type);
 281         Display.getDefault().asyncExec(new Runnable() {
 282             @Override
 283             public void run() {
 284                 AbstractUtility.executeMoniteredOperation("Import: " + configurator.getClass().getSimpleName(),
 285                         uuid,
 286                         1000,
 287                         false,
 288                         ImportManager.this,
 289                         null);
 290             }
 291         });
 292
 293     }
 294
 295         private IImportConfigurator getConfigurator(TYPE type) {
 296                 Assert.isNotNull(type, "Type should not be null");
 297
 298                 switch (type) {
 299                 case Jaxb:
 300                         return JaxbImportConfigurator.NewInstance(null, null);
 301                 case Tcs:
 302                         return TcsXmlImportConfigurator.NewInstance(null, null);
 303                 case Endnote:
 304                         return EndnoteImportConfigurator.NewInstance(null, null);
 305                 case Excel_Taxa:
 306                         return NormalExplicitImportConfigurator.NewInstance(null, null,
 307                                         null, null);
 308                 case Abcd:
 309                         return Abcd206ImportConfigurator.NewInstance(null, null);
 310                 case Sdd:
 311                         return SDDImportConfigurator.NewInstance(null, null);
 312                 case SpecimenCdmExcel:
 313                         return SpecimenCdmExcelImportConfigurator.NewInstance(null, null);
 314                 case SpecimenSearch:
 315                     return Abcd206ImportConfigurator.NewInstance(null, null);
 316                 case Gbif:
 317                     return DwcaImportConfigurator.NewInstance(null, null);
 318                 case Excel_Distribution:
 319             return ExcelDistributionUpdateConfigurator.NewInstance(null, null, null);
 320
 321                 default:
 322                         MessagingUtils.notImplementedMessage(this);
 323                         throw new IllegalArgumentException("Import not supported yet");
 324                 }
 325         }
 326
 327
 328         /**
 329          * <p>
 330          * JaxbConfigurator
 331          * </p>
 332          *
 333          * @return a {@link eu.etaxonomy.cdm.io.jaxb.JaxbImportConfigurator} object.
 334          */
 335         public final JaxbImportConfigurator JaxbConfigurator() {
 336                 return (JaxbImportConfigurator) getConfigurator(TYPE.Jaxb);
 337         }
 338
 339         /**
 340          * <p>
 341          * TcsConfigurator
 342          * </p>
 343          *
 344          * @return a {@link eu.etaxonomy.cdm.io.tcsxml.in.TcsXmlImportConfigurator}
 345          *         object.
 346          */
 347         public final TcsXmlImportConfigurator TcsConfigurator() {
 348                 return (TcsXmlImportConfigurator) getConfigurator(TYPE.Tcs);
 349         }
 350
 351         /**
 352          * <p>
 353          * EndnoteConfigurator
 354          * </p>
 355          *
 356          * @return a
 357          *         {@link eu.etaxonomy.cdm.io.reference.endnote.in.EndnoteImportConfigurator}
 358          *         object.
 359          */
 360         public final EndnoteImportConfigurator EndnoteConfigurator() {
 361                 return (EndnoteImportConfigurator) getConfigurator(TYPE.Endnote);
 362         }
 363
 364         /**
 365          * <p>
 366          * NormalExplicitConfigurator
 367          * </p>
 368          *
 369          * @return a
 370          *         {@link eu.etaxonomy.cdm.io.excel.taxa.NormalExplicitImportConfigurator}
 371          *         object.
 372          */
 373         public final NormalExplicitImportConfigurator NormalExplicitConfigurator() {
 374                 return (NormalExplicitImportConfigurator) getConfigurator(TYPE.Excel_Taxa);
 375         }
 376
 377         /**
 378          * <p>
 379          * SddConfigurator
 380          * </p>
 381          *
 382          * @return a {@link eu.etaxonomy.cdm.io.sdd.in.SDDImportConfigurator}
 383          *         object.
 384          */
 385         public final SDDImportConfigurator SddConfigurator() {
 386                 return (SDDImportConfigurator) getConfigurator(TYPE.Sdd);
 387         }
 388
 389         /**
 390          * <p>
 391          * AbcdConfigurator
 392          * </p>
 393          *
 394          * @return a
 395          *         {@link eu.etaxonomy.cdm.io.specimen.abcd206.in.Abcd206ImportConfigurator}
 396          *         object.
 397          */
 398         public final Abcd206ImportConfigurator AbcdConfigurator() {
 399                 return (Abcd206ImportConfigurator) getConfigurator(TYPE.Abcd);
 400         }
 401
 402         public SpecimenCdmExcelImportConfigurator SpecimenCdmExcelImportConfigurator() {
 403                 return (SpecimenCdmExcelImportConfigurator) getConfigurator(TYPE.SpecimenCdmExcel);
 404         }
 405
 406         public DwcaImportConfigurator DwcaImportConfigurator() {
 407                 return (DwcaImportConfigurator) getConfigurator(TYPE.Gbif);
 408         }
 409
 410
 411     /**
 412      * {@inheritDoc}
 413      */
 414     @Override
 415     public void postOperation(IRemotingProgressMonitor monitor) {
 416         Display.getDefault().asyncExec(new Runnable() {
 417
 418             @Override
 419             public void run() {
 420                 CdmStore.getContextManager().notifyContextRefresh();
 421             }
 422         });
 423
 424     }
 425
 426         public Job createIOServiceJob(final GbifImportConfigurator<GbifImportState, InputStream> configurator) {
 427                  Assert.isNotNull(configurator, "Configuration may not be null");
 428                 final Display display = Display.getDefault();
 429                 Job job = new Job("Import: " + " Dwca") {
 430
 431                     @Override
 432                     protected IStatus run(IProgressMonitor monitor) {
 433                         monitor.beginTask("Importing data", IProgressMonitor.UNKNOWN);
 434                         IIOService ioService = CdmApplicationState.getIOService();
 435
 436                         ImportResult result = ioService.importDataFromStream(configurator);
 437                         monitor.done();
 438
 439 //                      display.asyncExec(new Runnable() {
 440 //
 441 //                          @Override
 442 //                          public void run() {
 443 //                              CdmStore.getContextManager().notifyContextRefresh();
 444 //                          }
 445 //                      });
 446                         showResult("Gbif Import", display, result, importSuccessMessage);
 447                         return Status.OK_STATUS;
 448                     }
 449                 };
 450
 451                 return job;
 452
 453         }
 454
 455         public Job createIOServiceJob(final Abcd206ImportConfigurator configurator) {
 456                  Assert.isNotNull(configurator, "Configuration may not be null");
 457                 final Display display = Display.getDefault();
 458                 Job job = new Job("Import: " + " Dwca") {
 459
 460                     @Override
 461                     protected IStatus run(IProgressMonitor monitor) {
 462                         monitor.beginTask("Importing data", IProgressMonitor.UNKNOWN);
 463                         IIOService ioService = CdmApplicationState.getIOService();
 464
 465                         ImportResult result = ioService.importDataFromStream(configurator);
 466                         monitor.done();
 467
 468                         display.asyncExec(new Runnable() {
 469
 470                             @Override
 471                             public void run() {
 472                                 CdmStore.getContextManager().notifyContextRefresh();
 473                             }
 474                         });
 475                         showResult("Abcd Import", display, result, importSuccessMessage);
 476                         return Status.OK_STATUS;
 477                     }
 478                 };
 479
 480                 return job;
 481
 482         }
 483
 484         public Job createIOServiceJob(
 485                         final List<Abcd206ImportConfigurator> abcdConfigurators) {
 486                  Assert.isNotNull(abcdConfigurators, "Configuration may not be null");
 487                 final Display display = Display.getDefault();
 488                 Job job = new Job("Import: " + " Abcd") {
 489
 490                     @Override
 491                     protected IStatus run(IProgressMonitor monitor) {
 492                         monitor.beginTask("Importing data", IProgressMonitor.UNKNOWN);
 493                         IIOService ioService = CdmApplicationState.getIOService();
 494
 495                         ImportResult result = ioService.importDataFromStream(abcdConfigurators);
 496                         monitor.done();
 497
 498                         display.asyncExec(new Runnable() {
 499
 500                             @Override
 501                             public void run() {
 502                                 CdmStore.getContextManager().notifyContextRefresh();
 503                             }
 504                         });
 505                         showResult("Abcd Import", display, result, importSuccessMessage);
 506
 507
 508
 509                         return Status.OK_STATUS;
 510                     }
 511                 };
 512
 513                 return job;
 514         }
 515
 516     public Job createIOServiceJob(final ImportConfiguratorBase configurator) {
 517         Assert.isNotNull(configurator, "Configuration may not be null");
 518         final Display display = Display.getDefault();
 519
 520         Job job = new Job("Update: " + configurator.getClass().getSimpleName()) {
 521
 522             @Override
 523             protected IStatus run(IProgressMonitor monitor) {
 524                 monitor.beginTask("Updating data", IProgressMonitor.UNKNOWN);
 525                 IIOService ioService = CdmApplicationState.getIOService();
 526                 ImportResult importResult = null;
 527                 if (configurator instanceof SortIndexUpdaterConfigurator){
 528                     SortIndexUpdaterConfigurator config = (SortIndexUpdaterConfigurator)configurator;
 529                     importResult =ioService.updateSortIndex(config);
 530                 } else if (configurator instanceof CacheUpdaterConfigurator){
 531                     CacheUpdaterConfigurator config = (CacheUpdaterConfigurator) configurator;
 532                     importResult = ioService.updateCaches(config);
 533                 } else if (configurator instanceof ExcelDistributionUpdateConfigurator){
 534                     ExcelDistributionUpdateConfigurator config = (ExcelDistributionUpdateConfigurator) configurator;
 535                     importResult =ioService.updateDistributionData(config);
 536                 }
 537
 538                 monitor.done();
 539 //                display.asyncExec(new Runnable() {
 540 //
 541 //                    @Override
 542 //                    public void run() {
 543 //                        CdmStore.getContextManager().notifyContextRefresh();
 544 //                    }
 545 //                });
 546                 showResult(configurator.getClass().getSimpleName(), display, importResult, updateSuccessMessage);
 547
 548
 549                 return Status.OK_STATUS;
 550             }
 551
 552
 553         };
 554
 555         return job;
 556
 557     }
 558
 559     /**
 560      * @return
 561      */
 562     public ExcelDistributionUpdateConfigurator ExcelDistributionUpdateConfigurator() {
 563         return (ExcelDistributionUpdateConfigurator) getConfigurator(TYPE.Excel_Distribution);
 564     }
 565
 566
 567
 568
 569
 570
 571
 572 }