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
 264         } catch (Exception e) {
 265             MessagingUtils.errorDialog("Error importing input stream",
 266                     this,
 267                     e.getMessage(),
 268                     TaxeditorStorePlugin.PLUGIN_ID,
 269                     e,
 270                     true);
 271         }
 272
 273     }
 274
 275     public void runMoniteredOperation(final IImportConfigurator configurator, final byte[] data, final SOURCE_TYPE type) {
 276         IIOService ioService = CdmApplicationState.getIOService();
 277         final UUID uuid = ioService.monitImportData(configurator, data, type);
 278         Display.getDefault().asyncExec(new Runnable() {
 279             @Override
 280             public void run() {
 281                 AbstractUtility.executeMoniteredOperation("Import: " + configurator.getClass().getSimpleName(),
 282                         uuid,
 283                         1000,
 284                         false,
 285                         ImportManager.this,
 286                         null);
 287             }
 288         });
 289
 290     }
 291
 292         private IImportConfigurator getConfigurator(TYPE type) {
 293                 Assert.isNotNull(type, "Type should not be null");
 294
 295                 switch (type) {
 296                 case Jaxb:
 297                         return JaxbImportConfigurator.NewInstance(null, null);
 298                 case Tcs:
 299                         return TcsXmlImportConfigurator.NewInstance(null, null);
 300                 case Endnote:
 301                         return EndnoteImportConfigurator.NewInstance(null, null);
 302                 case Excel_Taxa:
 303                         return NormalExplicitImportConfigurator.NewInstance(null, null,
 304                                         null, null);
 305                 case Abcd:
 306                         return Abcd206ImportConfigurator.NewInstance(null, null);
 307                 case Sdd:
 308                         return SDDImportConfigurator.NewInstance(null, null);
 309                 case SpecimenCdmExcel:
 310                         return SpecimenCdmExcelImportConfigurator.NewInstance(null, null);
 311                 case SpecimenSearch:
 312                     return Abcd206ImportConfigurator.NewInstance(null, null);
 313                 case Gbif:
 314                     return DwcaImportConfigurator.NewInstance(null, null);
 315                 case Excel_Distribution:
 316             return ExcelDistributionUpdateConfigurator.NewInstance(null, null, null);
 317
 318                 default:
 319                         MessagingUtils.notImplementedMessage(this);
 320                         throw new IllegalArgumentException("Import not supported yet");
 321                 }
 322         }
 323
 324
 325         /**
 326          * <p>
 327          * JaxbConfigurator
 328          * </p>
 329          *
 330          * @return a {@link eu.etaxonomy.cdm.io.jaxb.JaxbImportConfigurator} object.
 331          */
 332         public final JaxbImportConfigurator JaxbConfigurator() {
 333                 return (JaxbImportConfigurator) getConfigurator(TYPE.Jaxb);
 334         }
 335
 336         /**
 337          * <p>
 338          * TcsConfigurator
 339          * </p>
 340          *
 341          * @return a {@link eu.etaxonomy.cdm.io.tcsxml.in.TcsXmlImportConfigurator}
 342          *         object.
 343          */
 344         public final TcsXmlImportConfigurator TcsConfigurator() {
 345                 return (TcsXmlImportConfigurator) getConfigurator(TYPE.Tcs);
 346         }
 347
 348         /**
 349          * <p>
 350          * EndnoteConfigurator
 351          * </p>
 352          *
 353          * @return a
 354          *         {@link eu.etaxonomy.cdm.io.reference.endnote.in.EndnoteImportConfigurator}
 355          *         object.
 356          */
 357         public final EndnoteImportConfigurator EndnoteConfigurator() {
 358                 return (EndnoteImportConfigurator) getConfigurator(TYPE.Endnote);
 359         }
 360
 361         /**
 362          * <p>
 363          * NormalExplicitConfigurator
 364          * </p>
 365          *
 366          * @return a
 367          *         {@link eu.etaxonomy.cdm.io.excel.taxa.NormalExplicitImportConfigurator}
 368          *         object.
 369          */
 370         public final NormalExplicitImportConfigurator NormalExplicitConfigurator() {
 371                 return (NormalExplicitImportConfigurator) getConfigurator(TYPE.Excel_Taxa);
 372         }
 373
 374         /**
 375          * <p>
 376          * SddConfigurator
 377          * </p>
 378          *
 379          * @return a {@link eu.etaxonomy.cdm.io.sdd.in.SDDImportConfigurator}
 380          *         object.
 381          */
 382         public final SDDImportConfigurator SddConfigurator() {
 383                 return (SDDImportConfigurator) getConfigurator(TYPE.Sdd);
 384         }
 385
 386         /**
 387          * <p>
 388          * AbcdConfigurator
 389          * </p>
 390          *
 391          * @return a
 392          *         {@link eu.etaxonomy.cdm.io.specimen.abcd206.in.Abcd206ImportConfigurator}
 393          *         object.
 394          */
 395         public final Abcd206ImportConfigurator AbcdConfigurator() {
 396                 return (Abcd206ImportConfigurator) getConfigurator(TYPE.Abcd);
 397         }
 398
 399         public SpecimenCdmExcelImportConfigurator SpecimenCdmExcelImportConfigurator() {
 400                 return (SpecimenCdmExcelImportConfigurator) getConfigurator(TYPE.SpecimenCdmExcel);
 401         }
 402
 403         public DwcaImportConfigurator DwcaImportConfigurator() {
 404                 return (DwcaImportConfigurator) getConfigurator(TYPE.Gbif);
 405         }
 406
 407
 408     /**
 409      * {@inheritDoc}
 410      */
 411     @Override
 412     public void postOperation(IRemotingProgressMonitor monitor) {
 413         Display.getDefault().asyncExec(new Runnable() {
 414
 415             @Override
 416             public void run() {
 417                 CdmStore.getContextManager().notifyContextRefresh();
 418             }
 419         });
 420
 421     }
 422
 423         public Job createIOServiceJob(final GbifImportConfigurator<GbifImportState, InputStream> configurator) {
 424                  Assert.isNotNull(configurator, "Configuration may not be null");
 425                 final Display display = Display.getDefault();
 426                 Job job = new Job("Import: " + " Dwca") {
 427
 428                     @Override
 429                     protected IStatus run(IProgressMonitor monitor) {
 430                         monitor.beginTask("Importing data", IProgressMonitor.UNKNOWN);
 431                         IIOService ioService = CdmApplicationState.getIOService();
 432
 433                         ImportResult result = ioService.importDataFromStream(configurator);
 434                         monitor.done();
 435
 436 //                      display.asyncExec(new Runnable() {
 437 //
 438 //                          @Override
 439 //                          public void run() {
 440 //                              CdmStore.getContextManager().notifyContextRefresh();
 441 //                          }
 442 //                      });
 443                         showResult("Gbif Import", display, result);
 444                         return Status.OK_STATUS;
 445                     }
 446                 };
 447
 448                 return job;
 449
 450         }
 451
 452         public Job createIOServiceJob(final Abcd206ImportConfigurator configurator) {
 453                  Assert.isNotNull(configurator, "Configuration may not be null");
 454                 final Display display = Display.getDefault();
 455                 Job job = new Job("Import: " + " Dwca") {
 456
 457                     @Override
 458                     protected IStatus run(IProgressMonitor monitor) {
 459                         monitor.beginTask("Importing data", IProgressMonitor.UNKNOWN);
 460                         IIOService ioService = CdmApplicationState.getIOService();
 461
 462                         ImportResult result = ioService.importDataFromStream(configurator);
 463                         monitor.done();
 464
 465                         display.asyncExec(new Runnable() {
 466
 467                             @Override
 468                             public void run() {
 469                                 CdmStore.getContextManager().notifyContextRefresh();
 470                             }
 471                         });
 472                         showResult("Abcd Import", display, result);
 473                         return Status.OK_STATUS;
 474                     }
 475                 };
 476
 477                 return job;
 478
 479         }
 480
 481         public Job createIOServiceJob(
 482                         final List<Abcd206ImportConfigurator> abcdConfigurators) {
 483                  Assert.isNotNull(abcdConfigurators, "Configuration may not be null");
 484                 final Display display = Display.getDefault();
 485                 Job job = new Job("Import: " + " Abcd") {
 486
 487                     @Override
 488                     protected IStatus run(IProgressMonitor monitor) {
 489                         monitor.beginTask("Importing data", IProgressMonitor.UNKNOWN);
 490                         IIOService ioService = CdmApplicationState.getIOService();
 491
 492                         ImportResult result = ioService.importDataFromStream(abcdConfigurators);
 493                         monitor.done();
 494
 495                         display.asyncExec(new Runnable() {
 496
 497                             @Override
 498                             public void run() {
 499                                 CdmStore.getContextManager().notifyContextRefresh();
 500                             }
 501                         });
 502                         showResult("Abcd Import", display, result);
 503
 504
 505
 506                         return Status.OK_STATUS;
 507                     }
 508                 };
 509
 510                 return job;
 511         }
 512
 513     public Job createIOServiceJob(final ImportConfiguratorBase configurator) {
 514         Assert.isNotNull(configurator, "Configuration may not be null");
 515         final Display display = Display.getDefault();
 516
 517         Job job = new Job("Update: " + configurator.getClass().getSimpleName()) {
 518
 519             @Override
 520             protected IStatus run(IProgressMonitor monitor) {
 521                 monitor.beginTask("Updating data", IProgressMonitor.UNKNOWN);
 522                 IIOService ioService = CdmApplicationState.getIOService();
 523                 ImportResult importResult = null;
 524                 if (configurator instanceof SortIndexUpdaterConfigurator){
 525                     SortIndexUpdaterConfigurator config = (SortIndexUpdaterConfigurator)configurator;
 526                     importResult =ioService.updateSortIndex(config);
 527                 } else if (configurator instanceof CacheUpdaterConfigurator){
 528                     CacheUpdaterConfigurator config = (CacheUpdaterConfigurator) configurator;
 529                     importResult = ioService.updateCaches(config);
 530                 } else if (configurator instanceof ExcelDistributionUpdateConfigurator){
 531                     ExcelDistributionUpdateConfigurator config = (ExcelDistributionUpdateConfigurator) configurator;
 532                     importResult =ioService.updateDistributionData(config);
 533                 }
 534
 535                 monitor.done();
 536 //                display.asyncExec(new Runnable() {
 537 //
 538 //                    @Override
 539 //                    public void run() {
 540 //                        CdmStore.getContextManager().notifyContextRefresh();
 541 //                    }
 542 //                });
 543                 showResult(configurator.getClass().getSimpleName(), display, importResult);
 544
 545
 546                 return Status.OK_STATUS;
 547             }
 548
 549
 550         };
 551
 552         return job;
 553
 554     }
 555
 556     /**
 557      * @return
 558      */
 559     public ExcelDistributionUpdateConfigurator ExcelDistributionUpdateConfigurator() {
 560         return (ExcelDistributionUpdateConfigurator) getConfigurator(TYPE.Excel_Distribution);
 561     }
 562
 563
 564
 565     /**
 566      * @param configurator
 567      * @param display
 568      * @param importResult
 569      */
 570     private void showResult(String importName, final Display display,
 571             ImportResult importResult) {
 572         StringBuffer reportTextTemp = importResult.createReport();
 573         final StringBuffer reportText;
 574         if (StringUtils.isBlank(reportTextTemp.toString())){
 575             reportTextTemp.append("No update result available");
 576             //TODO: this is a workaround because the abcd import writes the report in the report part...
 577             if (!importResult.getReports().isEmpty() && importResult.getReports().get(0) != null){
 578                 reportTextTemp = new StringBuffer();
 579                 if(importResult!=null){
 580                     List<byte[]> reports = importResult.getReports();
 581                     for (byte[] bs : reports) {
 582                         if (bs != null){ reportTextTemp.append(new String(bs));}
 583                     }
 584                 }
 585             }
 586         }
 587         reportText = reportTextTemp;
 588         display.asyncExec(new Runnable() {
 589
 590             @Override
 591             public void run() {
 592                 // display reports with possibility to save
 593                 ReportTextDialog dialog = new ReportTextDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell());
 594                 dialog.setTitle(importName+" Report");
 595                 dialog.setReportText(reportText.toString());
 596                 dialog.open();
 597                 CdmStore.getContextManager().notifyContextRefresh();
 598             }
 599         });
 600     }
 601
 602
 603
 604 }