Beispiel #1
0
  /** @see de.willuhn.jameica.gui.input.TextInput#setValue(java.lang.Object) */
  @Override
  public void setValue(Object value) {
    super.setValue(value);

    if (value == null) return;

    // Formatierungsleerzeichen zum Testen entfernen
    String s = StringUtils.trimToNull(StringUtils.deleteWhitespace(value.toString()));
    if (s == null) return;

    try {
      // 1. IBAN sofort checken
      IBAN iban = HBCIProperties.getIBAN(s);

      if (iban == null) // Keine IBAN
      return;

      if (this.bicInput == null) return;

      // 2. Wenn wir ein BICInput haben, dann gleich noch die BIC ermitteln und
      // vervollstaendigen
      String bic = StringUtils.trimToNull(iban.getBIC());
      if (bic == null) return;

      this.bicInput.setValue(bic);
    } catch (ApplicationException ae) {
      Application.getMessagingFactory()
          .sendMessage(new StatusBarMessage(ae.getMessage(), StatusBarMessage.TYPE_ERROR));
    }
  }
  /**
   * Stellt die Nachricht an alle Consumer zu.
   *
   * @param consumers die Message-Consumer.
   * @param msg
   */
  private void deliver(Message msg) {
    if (pool.isTerminating() || pool.isTerminated()) {
      Logger.warn("shutdown in progress, no more messages accepted");
      return; // wir nehmen keine Nachrichten mehr entgegen.
    }

    // BUGZILLA 1413 Wir koennen leider doch nicht auf einer Kopie der Liste arbeiten, weil
    // diese waehrend der Zustellung erweitert werden kann. Z.bsp. der "AutoRegisterMessageConsumer"
    // erhaelt die SYSTEM_STARTED-Message und registriert daraufhin neue Consumer. Unter anderem
    // den DeployMessageConsumer aus jameica.webadmin, der ebenfalls auf die SYSTEM_STARTED-Message
    // lauscht.
    Logger.debug("deliver message " + msg.toString());
    MessageConsumer consumer = null;
    for (int i = 0; i < this.consumers.size(); ++i) {
      consumer = this.consumers.get(i);
      Class[] expected = consumer.getExpectedMessageTypes();
      boolean send = expected == null;
      if (expected != null) {
        for (int j = 0; j < expected.length; ++j) {
          if (expected[j].isInstance(msg)) {
            send = true;
            break;
          }
        }
      }
      try {
        if (send) consumer.handleMessage(msg);
      } catch (ApplicationException ae) {
        Application.getMessagingFactory()
            .sendSyncMessage(new StatusBarMessage(ae.getMessage(), StatusBarMessage.TYPE_ERROR));
      } catch (OperationCanceledException oce) {
        Logger.debug("consumer " + consumer.getClass().getName() + " cancelled message " + msg);
      } catch (Throwable t) {
        Logger.error(
            "consumer "
                + consumer.getClass().getName()
                + " produced an error ("
                + t.getClass().getName()
                + ": "
                + t
                + ") while consuming message "
                + msg);
        Logger.write(Level.INFO, "error while processing message", t);
      }
    }
  }
Beispiel #3
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);
        }
      }
    }
  }