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