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