Beispiel #1
0
  /**
   * @see de.willuhn.jameica.hbci.io.Importer#doImport(java.lang.Object,
   *     de.willuhn.jameica.hbci.io.IOFormat, java.io.InputStream, de.willuhn.util.ProgressMonitor)
   */
  public void doImport(Object context, IOFormat format, InputStream is, ProgressMonitor monitor)
      throws RemoteException, ApplicationException {

    if (is == null)
      throw new ApplicationException(i18n.tr("Keine zu importierende Datei ausgewählt"));

    if (format == null) throw new ApplicationException(i18n.tr("Kein Datei-Format ausgewählt"));

    final ClassLoader loader =
        Application.getPluginLoader().getManifest(HBCI.class).getClassLoader();
    Reader reader = null;
    try {
      reader =
          new XmlReader(
              is,
              new ObjectFactory() {
                public GenericObject create(String type, String id, Map values) throws Exception {
                  AbstractDBObject object =
                      (AbstractDBObject)
                          Settings.getDBService().createObject(loader.loadClass(type), null);
                  // object.setID(id); // Keine ID angeben, da wir die Daten neu anlegen wollen
                  Iterator i = values.keySet().iterator();
                  while (i.hasNext()) {
                    String name = (String) i.next();
                    object.setAttribute(name, values.get(name));
                  }
                  return object;
                }
              });

      if (monitor != null) monitor.setStatusText(i18n.tr("Lese Datei ein"));

      int created = 0;
      int error = 0;

      DBObject object = null;
      while ((object = (DBObject) reader.read()) != null) {
        if (monitor != null) {
          monitor.log(i18n.tr("Datensatz {0}", "" + (created + 1)));
          if (created > 0 && created % 10 == 0) // nur geschaetzt
          monitor.addPercentComplete(1);
        }

        try {
          object.store();
          created++;
          try {
            Application.getMessagingFactory().sendMessage(new ImportMessage(object));
          } catch (Exception ex) {
            Logger.error("error while sending import message", ex);
          }
        } catch (ApplicationException ae) {
          monitor.log("  " + ae.getMessage());
          error++;
        } catch (Exception e) {
          Logger.error("unable to import line", e);
          monitor.log("  " + i18n.tr("Fehler beim Import des Datensatzes: {0}", e.getMessage()));
          error++;
        }
      }
      monitor.setStatusText(
          i18n.tr(
              "{0} Datensätze erfolgreich importiert, {1} fehlerhafte übersprungen",
              new String[] {"" + created, "" + error}));
      monitor.setPercentComplete(100);
    } catch (OperationCanceledException oce) {
      Logger.warn("operation cancelled");
      throw new ApplicationException(i18n.tr("Import abgebrochen"));
    } catch (Exception e) {
      Logger.error("error while reading file", e);
      throw new ApplicationException(i18n.tr("Fehler beim Import der XML-Datei"));
    } finally {
      if (reader != null) {
        try {
          reader.close();
        } catch (IOException e) {
          Logger.error("error while closing inputstream", e);
        }
      }
    }
  }
  /**
   * @see de.willuhn.jameica.hbci.io.Exporter#doExport(java.lang.Object[],
   *     de.willuhn.jameica.hbci.io.IOFormat, java.io.OutputStream, de.willuhn.util.ProgressMonitor)
   */
  public void doExport(Object[] objects, IOFormat format, OutputStream os, ProgressMonitor monitor)
      throws RemoteException, ApplicationException {
    if (os == null)
      throw new ApplicationException(i18n.tr("Kein Ausgabe-Ziel für die Datei angegeben"));

    if (format == null) throw new ApplicationException(i18n.tr("Kein Ausgabe-Format angegeben"));

    if (objects == null || objects.length == 0)
      throw new ApplicationException(i18n.tr("Keine zu exportierenden Daten angegeben"));

    if (!(objects instanceof SammelTransfer[]))
      throw new ApplicationException(
          i18n.tr("Die zu exportierenden Daten enthalten keine Sammel-Aufträge"));

    DtausDateiWriter writer = null;

    try {
      writer = new DtausDateiWriter(os);
      for (int i = 0; i < objects.length; ++i) {
        SammelTransfer transfer = (SammelTransfer) objects[i];
        Konto konto = transfer.getKonto();
        GenericIterator buchungen = transfer.getBuchungen();

        monitor.setPercentComplete(0);
        monitor.setStatusText(i18n.tr("Exportiere logische Datei Nr. {0}", "" + (i + 1)));

        double factor = 100d / buchungen.size();
        int count = 0;
        int success = 0;

        long kundenNummer = 0;
        String s = konto.getKundennummer();
        try {
          kundenNummer = Long.parseLong(s);
        } catch (Exception e) {
          monitor.log(i18n.tr("Ignoriere Kundennummer {0}: ungültig", s));
        }

        long blz = 0;
        s = konto.getBLZ();
        try {
          blz = Long.parseLong(s);
        } catch (Exception e) {
          monitor.log(i18n.tr("Ignoriere BLZ {0}: ungültig", s));
        }

        writer.open();
        writer.setAAusfuehrungsdatum(transfer.getTermin());
        writer.setABLZBank(blz);

        String type = (transfer instanceof SammelUeberweisung) ? "GK" : "LK";
        writer.setAGutschriftLastschrift(type);

        writer.setAKonto(Long.parseLong(konto.getKontonummer()));
        writer.setAKundenname(konto.getName());
        writer.writeASatz();

        while (buchungen.hasNext()) {
          // Mit diesem Factor sollte sich der Fortschrittsbalken
          // bis zum Ende der DTAUS-Datei genau auf 100% bewegen
          monitor.setPercentComplete((int) ((++count) * factor));

          SammelTransferBuchung buchung = (SammelTransferBuchung) buchungen.next();

          monitor.log(i18n.tr("Exportiere Datensatz {0}", buchung.getGegenkontoName()));

          writer.setCBetragInEuro(buchung.getBetrag());
          writer.setCBLZEndbeguenstigt(Long.parseLong(buchung.getGegenkontoBLZ()));
          writer.setCBLZErstbeteiligtesInstitut(blz);
          writer.setCKonto(Long.parseLong(buchung.getGegenkontoNummer()));
          writer.setCName(buchung.getGegenkontoName());
          writer.setCInterneKundennummer(kundenNummer);
          writer.setCTextschluessel(mapTextschluesselToDtaus(buchung));

          String[] lines = VerwendungszweckUtil.toArray(buchung);
          for (String line : lines) writer.addCVerwendungszweck(line);

          writer.writeCSatz();
          success++;
        }
        monitor.setStatusText(i18n.tr("{0} Aufträge erfolgreich exportiert", "" + success));
      }
      writer.writeESatz();
    } catch (OperationCanceledException oce) {
      Logger.info("operation cancelled");
      monitor.setStatusText(i18n.tr("Export abgebrochen"));
      monitor.setStatus(ProgressMonitor.STATUS_CANCEL);
    } catch (ApplicationException ae) {
      throw ae;
    } catch (DtausException dta) {
      Logger.error(dta.getMessage(), dta);
      throw new ApplicationException(i18n.tr(dta.getLocalizedMessage()));
    } catch (Exception e) {
      throw new RemoteException(i18n.tr("Fehler beim Export der Daten"), e);
    } finally {
      if (writer != null) {
        try {
          writer.close();
          os = null;
        } catch (Exception e) {
          Logger.error("error while closing dtaus writer", e);
        }
      }
      // Outputstream schliessen, falls das noch nicht geschehen ist
      if (os != null) {
        try {
          os.close();
        } catch (Throwable t) {
          Logger.error("unable to close file", t);
        }
      }
    }
  }