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

   1 // $Id$
   2 /**
   3  * Copyright (C) 2007 EDIT
   4  * European Distributed Institute of Taxonomy
   5  * http://www.e-taxonomy.eu
   6  *
   7  * The contents of this file are subject to the Mozilla Public License Version 1.1
   8  * See LICENSE.TXT at the top of this package for the full license terms.
   9  */
  10
  11 package eu.etaxonomy.taxeditor.io;
  12
  13 import java.io.File;
  14 import java.io.InputStream;
  15 import java.net.URI;
  16 import java.nio.file.Files;
  17 import java.nio.file.Path;
  18 import java.nio.file.Paths;
  19 import java.util.List;
  20 import java.util.Set;
  21 import java.util.UUID;
  22
  23 import org.apache.commons.io.IOUtils;
  24 import org.eclipse.core.runtime.Assert;
  25 import org.eclipse.core.runtime.IProgressMonitor;
  26 import org.eclipse.core.runtime.IStatus;
  27 import org.eclipse.core.runtime.Status;
  28 import org.eclipse.core.runtime.jobs.Job;
  29 import org.eclipse.swt.widgets.Display;
  30 import org.eclipse.ui.PlatformUI;
  31
  32 import eu.etaxonomy.cdm.api.application.CdmApplicationState;
  33 import eu.etaxonomy.cdm.api.application.ICdmApplicationConfiguration;
  34 import eu.etaxonomy.cdm.common.monitor.IRemotingProgressMonitor;
  35 import eu.etaxonomy.cdm.io.common.CdmDefaultImport;
  36 import eu.etaxonomy.cdm.io.common.IImportConfigurator;
  37 import eu.etaxonomy.cdm.io.common.IImportConfigurator.SOURCE_TYPE;
  38 import eu.etaxonomy.cdm.io.common.ImportResult;
  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.SpecimenImportConfiguratorBase;
  46 import eu.etaxonomy.cdm.io.specimen.abcd206.in.Abcd206ImportConfigurator;
  47 import eu.etaxonomy.cdm.io.specimen.abcd206.in.Abcd206ImportState;
  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(ICdmApplicationConfiguration 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                         ICdmApplicationConfiguration 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                 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
 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                 default:
 315                         MessagingUtils.notImplementedMessage(this);
 316                         throw new IllegalArgumentException("Import not supported yet");
 317                 }
 318         }
 319
 320
 321         /**
 322          * <p>
 323          * JaxbConfigurator
 324          * </p>
 325          *
 326          * @return a {@link eu.etaxonomy.cdm.io.jaxb.JaxbImportConfigurator} object.
 327          */
 328         public final JaxbImportConfigurator JaxbConfigurator() {
 329                 return (JaxbImportConfigurator) getConfigurator(TYPE.Jaxb);
 330         }
 331
 332         /**
 333          * <p>
 334          * TcsConfigurator
 335          * </p>
 336          *
 337          * @return a {@link eu.etaxonomy.cdm.io.tcsxml.in.TcsXmlImportConfigurator}
 338          *         object.
 339          */
 340         public final TcsXmlImportConfigurator TcsConfigurator() {
 341                 return (TcsXmlImportConfigurator) getConfigurator(TYPE.Tcs);
 342         }
 343
 344         /**
 345          * <p>
 346          * EndnoteConfigurator
 347          * </p>
 348          *
 349          * @return a
 350          *         {@link eu.etaxonomy.cdm.io.reference.endnote.in.EndnoteImportConfigurator}
 351          *         object.
 352          */
 353         public final EndnoteImportConfigurator EndnoteConfigurator() {
 354                 return (EndnoteImportConfigurator) getConfigurator(TYPE.Endnote);
 355         }
 356
 357         /**
 358          * <p>
 359          * NormalExplicitConfigurator
 360          * </p>
 361          *
 362          * @return a
 363          *         {@link eu.etaxonomy.cdm.io.excel.taxa.NormalExplicitImportConfigurator}
 364          *         object.
 365          */
 366         public final NormalExplicitImportConfigurator NormalExplicitConfigurator() {
 367                 return (NormalExplicitImportConfigurator) getConfigurator(TYPE.Excel_Taxa);
 368         }
 369
 370         /**
 371          * <p>
 372          * SddConfigurator
 373          * </p>
 374          *
 375          * @return a {@link eu.etaxonomy.cdm.io.sdd.in.SDDImportConfigurator}
 376          *         object.
 377          */
 378         public final SDDImportConfigurator SddConfigurator() {
 379                 return (SDDImportConfigurator) getConfigurator(TYPE.Sdd);
 380         }
 381
 382         /**
 383          * <p>
 384          * AbcdConfigurator
 385          * </p>
 386          *
 387          * @return a
 388          *         {@link eu.etaxonomy.cdm.io.specimen.abcd206.in.Abcd206ImportConfigurator}
 389          *         object.
 390          */
 391         public final Abcd206ImportConfigurator AbcdConfigurator() {
 392                 return (Abcd206ImportConfigurator) getConfigurator(TYPE.Abcd);
 393         }
 394
 395         public SpecimenCdmExcelImportConfigurator SpecimenCdmExcelImportConfigurator() {
 396                 return (SpecimenCdmExcelImportConfigurator) getConfigurator(TYPE.SpecimenCdmExcel);
 397         }
 398
 399         public DwcaImportConfigurator DwcaImportConfigurator() {
 400                 return (DwcaImportConfigurator) getConfigurator(TYPE.Gbif);
 401         }
 402
 403
 404     /**
 405      * {@inheritDoc}
 406      */
 407     @Override
 408     public void postOperation(IRemotingProgressMonitor monitor) {
 409         Display.getDefault().asyncExec(new Runnable() {
 410
 411             @Override
 412             public void run() {
 413                 CdmStore.getContextManager().notifyContextRefresh();
 414             }
 415         });
 416
 417     }
 418
 419         public Job createIOServiceJob(final GbifImportConfigurator<GbifImportState, InputStream> configurator) {
 420                  Assert.isNotNull(configurator, "Configuration may not be null");
 421                 final Display display = Display.getDefault();
 422                 Job job = new Job("Import: " + " Dwca") {
 423
 424                     @Override
 425                     protected IStatus run(IProgressMonitor monitor) {
 426                         monitor.beginTask("Importing data", IProgressMonitor.UNKNOWN);
 427                         IIOService ioService = CdmApplicationState.getIOService();
 428
 429                         ImportResult result = ioService.importDataFromStream(configurator);
 430                         monitor.done();
 431
 432                         display.asyncExec(new Runnable() {
 433
 434                             @Override
 435                             public void run() {
 436                                 CdmStore.getContextManager().notifyContextRefresh();
 437                             }
 438                         });
 439
 440                         return Status.OK_STATUS;
 441                     }
 442                 };
 443
 444                 return job;
 445
 446         }
 447
 448         public Job createIOServiceJob(final Abcd206ImportConfigurator<Abcd206ImportState, InputStream> configurator) {
 449                  Assert.isNotNull(configurator, "Configuration may not be null");
 450                 final Display display = Display.getDefault();
 451                 Job job = new Job("Import: " + " Dwca") {
 452
 453                     @Override
 454                     protected IStatus run(IProgressMonitor monitor) {
 455                         monitor.beginTask("Importing data", IProgressMonitor.UNKNOWN);
 456                         IIOService ioService = CdmApplicationState.getIOService();
 457
 458                         ImportResult result = ioService.importDataFromStream(configurator);
 459                         monitor.done();
 460
 461                         display.asyncExec(new Runnable() {
 462
 463                             @Override
 464                             public void run() {
 465                                 CdmStore.getContextManager().notifyContextRefresh();
 466                             }
 467                         });
 468
 469                         return Status.OK_STATUS;
 470                     }
 471                 };
 472
 473                 return job;
 474
 475         }
 476
 477         public Job createIOServiceJob(
 478                         final List<Abcd206ImportConfigurator> abcdConfigurators) {
 479                  Assert.isNotNull(abcdConfigurators, "Configuration may not be null");
 480                 final Display display = Display.getDefault();
 481                 Job job = new Job("Import: " + " Dwca") {
 482
 483                     @Override
 484                     protected IStatus run(IProgressMonitor monitor) {
 485                         monitor.beginTask("Importing data", IProgressMonitor.UNKNOWN);
 486                         IIOService ioService = CdmApplicationState.getIOService();
 487
 488                         ImportResult result = ioService.importDataFromStream(abcdConfigurators);
 489                         monitor.done();
 490
 491                         display.asyncExec(new Runnable() {
 492
 493                             @Override
 494                             public void run() {
 495                                 CdmStore.getContextManager().notifyContextRefresh();
 496                             }
 497                         });
 498
 499                         return Status.OK_STATUS;
 500                     }
 501                 };
 502
 503                 return job;
 504         }
 505
 506
 507
 508
 509 }