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