/**
  * Loescht den permanenten Store mit den PINs.
  *
  * @param passport der Passport, dessen PIN geloescht werden soll. Optional. Wird er weggelassen,
  *     werden alle PINs geloescht.
  */
 public static void clearPINStore(HBCIPassport passport) {
   try {
     if (passport != null) {
       // Wir loeschen nur das Passwort vom angegebenen Passport
       String key = getCacheKey(passport);
       if (key != null && Settings.getWallet().get(key) != null) {
         // Nur loeschen, wenn es den Key auch wirklich gibt. Das spart
         // den Schreibzugriff, wenn er nicht vorhanden ist
         Settings.getWallet().delete(key);
       }
       // Wenn kein Key existiert, haben wir auch nichts zu loeschen,
       // weil dann gar kein Passwort im Store existieren kann
     } else {
       // Alles Keys beginnen mit "hibiscus.pin."
       Settings.getWallet().deleteAll("hibiscus.pin.");
     }
   } catch (Exception e) {
     // Wenn das fehlschlaegt, sollte man eigentlich mehr Alarm schlagen
     // Allerdings wuesste ich jetzt auch nicht, was der User dann machen
     // kann, ausser dem Loeschen der Wallet-Datei. Was aber dazu fuehren
     // wuerde, dass saemtliche DDV- und PinTan-Passport-Files nicht mehr
     // gelesen werden koennen, weil fuer die ja Random-Passworte verwendet
     // werden, die ebenfalls im Wallet gespeichert sind
     Logger.error("unable to clear pin cache", e);
   }
 }
  /**
   * Speichert die PIN temporaer fuer diese Session.
   *
   * @param passport der Passport.
   * @param pin die PIN.
   * @throws Exception
   */
  private static void setCachedPIN(HBCIPassport passport, String pin) throws Exception {
    String key = getCacheKey(passport);

    // Kein Key, dann muessen wir nicht cachen
    if (key == null) return;

    ByteArrayInputStream bis = new ByteArrayInputStream(pin.getBytes());
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    Application.getSSLFactory().encrypt(bis, bos);
    byte[] crypted = bos.toByteArray();

    if (Settings.getCachePin()) {
      pinCache.put(key, crypted);
    }

    // Permanentes Speichern der PIN gibts nur bei PIN/TAN, da dort ueber
    // die TAN eine weitere Autorisierung bei der Ausfuehrung von Geschaeftsvorfaellen
    // mit Geldfluss stattfindet. Bei DDV/RDH koennte man sonst beliebig Geld
    // transferieren, ohne jemals wieder nach einem Passwort gefragt zu werden.
    if (Settings.getStorePin() && (passport instanceof HBCIPassportPinTan)) {
      // Nicht direkt das Byte-Array speichern sondern einen Base64-String.
      // Grund: Bei einem Byte-Array wuerde der XML-Serializer fuer jedes
      // Byte ein einzelnes XML-Element anlegen und damit das Wallet aufblasen
      Settings.getWallet().set(key, Base64.encode(crypted));
    }
  }
  /** @see de.willuhn.jameica.hbci.passports.pintan.rmi.PinTanConfig#getKonten() */
  public Konto[] getKonten() throws RemoteException {
    // Und jetzt laden wir die Liste neu
    String[] ids = settings.getList(getID() + ".konto", null);
    if (ids == null || ids.length == 0) return null;

    List<String> fixedIds = new ArrayList<String>();
    List<Konto> konten = new ArrayList<Konto>();
    for (int i = 0; i < ids.length; ++i) {
      try {
        konten.add(
            (Konto)
                de.willuhn.jameica.hbci.Settings.getDBService().createObject(Konto.class, ids[i]));
        fixedIds.add(ids[i]); // Wenn das Konto geladen wurde, bleibt es erhalten
      } catch (ObjectNotFoundException noe) {
        Logger.warn("account " + ids[i] + " does not exist, removing from list");
      } catch (RemoteException re) {
        throw re;
      }
    }
    if (fixedIds.size() != ids.length) {
      Logger.info("fixing list of assigned accounts");
      settings.setAttribute(getID() + ".konto", fixedIds.toArray(new String[fixedIds.size()]));
    }
    return konten.toArray(new Konto[konten.size()]);
  }
  /**
   * Hilfsfunktion zum Ermitteln des Keys, zu dem die PIN gespeichert ist.
   *
   * @param passport
   * @return die PIN oder null.
   */
  private static String getCacheKey(HBCIPassport passport) {
    // Entweder das Cachen ist abgeschaltet oder wir haben keinen Passport
    if (!Settings.getCachePin() || passport == null) {
      Logger.debug("pin caching disabled or no passport set");
      return null;
    }

    String key = null;
    // PIN/TAN
    if (passport instanceof HBCIPassportPinTan) key = ((HBCIPassportPinTan) passport).getFileName();

    // Schluesseldiskette
    else if (passport instanceof AbstractRDHSWFileBasedPassport)
      key = ((AbstractRDHSWFileBasedPassport) passport).getFilename();

    // DDV
    else if (passport instanceof HBCIPassportDDV) key = ((HBCIPassportDDV) passport).getFileName();

    if (key != null) {
      key = "hibiscus.pin." + key;
      Logger.debug("using cache key: " + key);
      return key;
    }

    Logger.warn(
        "unknown passport type ["
            + passport.getClass().getName()
            + "], don't know, how to cache pin");
    return null;
  }
  /**
   * Ueberschrieben, damit wir bei Bedarf eine neue Ueberweisung erzeugen koennen.
   *
   * @see de.willuhn.jameica.hbci.gui.controller.AbstractTransferControl#getTransfer()
   */
  public HibiscusTransfer getTransfer() throws RemoteException {
    if (transfer != null) return transfer;

    transfer = (Ueberweisung) getCurrentObject();
    if (transfer != null) return transfer;

    transfer = (Ueberweisung) Settings.getDBService().createObject(Ueberweisung.class, null);
    return transfer;
  }
  /**
   * Prueft, ob eine gespeicherte PIN fuer diesen Passport vorliegt.
   *
   * @param passport der Passport.
   * @return die PIN oder null, wenn keine gefunden wurde.
   * @throws Exception
   */
  private static String getCachedPIN(HBCIPassport passport) throws Exception {
    String key = getCacheKey(passport);

    // Kein Key - dann brauchen wir auch nicht im Cache schauen
    if (key == null) return null;

    byte[] data = null;

    // Cache checken
    if (Settings.getCachePin()) {
      data = pinCache.get(key);
    }

    // Wenn wir noch nichts im Cache haben, schauen wir im Wallet - wenn das erlaubt ist
    if (data == null && Settings.getStorePin() && (passport instanceof HBCIPassportPinTan)) {
      String s = (String) Settings.getWallet().get(key);
      if (s != null) {
        data = Base64.decode(s);

        // Wenn diese Meldung im Log erscheint, gibts keinen Support mehr von mir.
        // Wer die PIN permament speichert, tut das auf eigenes Risiko
        Logger.info("pin loaded from wallet");
        // Uebernehmen wir gleich in den Cache, damit wir beim
        // naechsten Mal direkt im Cache schauen koennen und nicht
        // mehr im Wallet
        pinCache.put(key, data);
      }
    }

    // Haben wir Daten?
    if (data != null) {
      ByteArrayInputStream bis = new ByteArrayInputStream(data);
      ByteArrayOutputStream bos = new ByteArrayOutputStream();
      Application.getSSLFactory().decrypt(bis, bos);
      String s = bos.toString();
      if (s != null && s.length() > 0) return s;
    }

    return null;
  }
  /**
   * Versucht eine SEPA-Ueberweisung aus der Zwischenablage zu erstellen.
   *
   * @return die Ueberweisung, wenn eine erstellt werden konnte oder null.
   */
  public AuslandsUeberweisung getUeberweisung() {
    try {
      // BUGZILLA 336
      final Clipboard cb = new Clipboard(GUI.getDisplay());
      TextTransfer transfer = TextTransfer.getInstance();
      String text = (String) cb.getContents(transfer);

      if (text == null || text.length() == 0) return null;

      text = text.trim();

      // Fuer den Fall, dass wir Key+Value nicht nur durch Doppelpunkt sondern zusaetzlich
      // auch noch durch einen Zeilenumbruch getrennt sind, entfernen wir Zeilen-Umbrueche,
      // wenn sie auf einen Doppelpunkt folgen
      // Siehe http://www.onlinebanking-forum.de/phpBB2/viewtopic.php?p=82519#82519
      text = PT_SPLIT.matcher(text).replaceAll(":");

      StringTokenizer st = new StringTokenizer(text, System.getProperty("line.separator", "\n"));
      HashMap values = new HashMap();

      while (st.hasMoreTokens()) {
        String line = st.nextToken();
        if (line == null || line.length() <= 0) continue;

        line = line.replaceAll("\\s", " ");

        int sep = line.indexOf(":");
        if (sep == -1) continue;

        values.put(line.substring(0, sep).trim(), line.substring(sep + 1).trim());
      }

      AuslandsUeberweisung u =
          (AuslandsUeberweisung)
              Settings.getDBService().createObject(AuslandsUeberweisung.class, null);

      Iterator i = values.keySet().iterator();
      while (i.hasNext()) {
        String s = (String) i.next();
        String value = (String) values.get(s);
        if (value == null || s == null) continue;
        if (PT_BLZ.matcher(s).matches()) u.setGegenkontoBLZ(value.replaceAll(" ", ""));
        else if (PT_KONTO.matcher(s).matches()) u.setGegenkontoNummer(value.replaceAll(" ", ""));
        else if (PT_NAME.matcher(s).matches()) u.setGegenkontoName(value);
        else if (PT_ZWECK.matcher(s).matches()) u.setZweck(value);
      }
      return u;
    } catch (Throwable t) {
      Logger.debug("unable to parse clipboard data: " + t.getMessage());
    }
    return null;
  }
  /**
   * Ermittelt die Liste der Zeilen fuer die Tabelle.
   *
   * @return Liste mit den Werten.
   * @throws RemoteException
   */
  private List<EinnahmeAusgabe> getWerte() throws RemoteException {
    List<EinnahmeAusgabe> list = new ArrayList<EinnahmeAusgabe>();

    Konto konto = (Konto) getKontoAuswahl().getValue();
    Date start = (Date) this.getStart().getValue();
    Date end = (Date) this.getEnd().getValue();

    // Uhrzeit zuruecksetzen, falls vorhanden
    if (start != null) start = DateUtil.startOfDay(start);
    if (end != null) end = DateUtil.startOfDay(end);

    // Wird nur ein Konto ausgewertet?
    if (konto != null) {
      list.add(new EinnahmeAusgabe(konto, start, end));
      return list;
    }

    // Alle Konten
    double summeAnfangssaldo = 0.0d;
    double summeEinnahmen = 0.0d;
    double summeAusgaben = 0.0d;
    double summeEndsaldo = 0.0d;

    DBIterator it = de.willuhn.jameica.hbci.Settings.getDBService().createList(Konto.class);
    it.setOrder("ORDER BY blz, kontonummer");
    while (it.hasNext()) {
      EinnahmeAusgabe ea = new EinnahmeAusgabe((Konto) it.next(), start, end);

      // Zu den Summen hinzufuegen
      summeAnfangssaldo += ea.getAnfangssaldo();
      summeEinnahmen += ea.getEinnahmen();
      summeAusgaben += ea.getAusgaben();
      summeEndsaldo += ea.getEndsaldo();
      list.add(ea);
    }

    // Summenzeile noch hinten dran haengen
    EinnahmeAusgabe summen = new EinnahmeAusgabe();
    summen.setIsSumme(true);
    summen.setText(i18n.tr("Summe"));
    summen.setAnfangssaldo(summeAnfangssaldo);
    summen.setAusgaben(summeAusgaben);
    summen.setEinnahmen(summeEinnahmen);
    summen.setEndsaldo(summeEndsaldo);
    summen.setEnddatum((Date) this.getStart().getValue());
    summen.setStartdatum((Date) this.getEnd().getValue());
    list.add(summen);

    return list;
  }
  /**
   * @see de.willuhn.jameica.hbci.gui.parts.AbstractFromToList#getList(java.util.Date,
   *     java.util.Date, java.lang.String)
   */
  protected DBIterator getList(Date from, Date to, String text) throws RemoteException {
    HBCIDBService service = (HBCIDBService) Settings.getDBService();

    DBIterator list = service.createList(getObjectType());
    if (from != null)
      list.addFilter(
          "termin >= ?", new Object[] {new java.sql.Date(DateUtil.startOfDay(from).getTime())});
    if (to != null)
      list.addFilter(
          "termin <= ?", new Object[] {new java.sql.Date(DateUtil.endOfDay(to).getTime())});
    if (text != null && text.length() > 0) {
      list.addFilter("LOWER(bezeichnung) like ?", new Object[] {"%" + text.toLowerCase() + "%"});
    }
    list.setOrder("ORDER BY " + service.getSQLTimestamp("termin") + " DESC, id DESC");
    return list;
  }
  /** @see de.willuhn.jameica.search.SearchProvider#search(java.lang.String) */
  public List search(String search) throws RemoteException, ApplicationException {
    if (search == null || search.length() == 0) return null;

    String text = "%" + search.toLowerCase() + "%";
    HBCIDBService service = (HBCIDBService) Settings.getDBService();
    DBIterator list = service.createList(AuslandsUeberweisung.class);
    list.addFilter(
        "LOWER(zweck) LIKE ? OR "
            + "LOWER(empfaenger_name) LIKE ? OR "
            + "LOWER(endtoendid) LIKE ? OR "
            + "LOWER(empfaenger_konto) LIKE ?",
        text,
        text,
        text,
        text);
    list.setOrder("ORDER BY " + service.getSQLTimestamp("termin") + " DESC");

    ArrayList results = new ArrayList();
    while (list.hasNext()) {
      results.add(new MyResult((AuslandsUeberweisung) list.next()));
    }
    return results;
  }
Exemple #11
0
 /** @see de.willuhn.jameica.gui.boxes.Box#isActive() */
 public boolean isActive() {
   return super.isActive() && !Settings.isFirstStart();
 }
    /** @see org.eclipse.swt.widgets.Listener#handleEvent(org.eclipse.swt.widgets.Event) */
    public void handleEvent(Event event) {
      if (chart == null) return;

      try {
        int start = ((Integer) getRange().getValue()).intValue();

        Konto k = konto;
        if (k == null) // Das ist der Fall, wenn das Kontoauswahlfeld verfuegbar ist
        k = (Konto) getKontoAuswahl().getValue();

        if (start == startPrev && k == kPrev) return; // Auswahl nicht geaendert

        chart.removeAllData();

        Date date = null;

        if (start < 0) {
          // Keine Anzahl von Tagen angegeben. Dann nehmen wir den
          // aeltesten gefundenen Umsatz als Beginn
          String query = "select min(valuta) from umsatz";
          if (k != null) query += " where konto_id = " + k.getID();

          date =
              (Date)
                  Settings.getDBService()
                      .execute(
                          query,
                          null,
                          new ResultSetExtractor() {
                            public Object extract(ResultSet rs)
                                throws RemoteException, SQLException {
                              if (!rs.next()) return null;
                              return rs.getDate(1);
                            }
                          });
        } else {
          long d = start * 24l * 60l * 60l * 1000l;
          date = DateUtil.startOfDay(new Date(System.currentTimeMillis() - d));
        }

        if (date == null) {
          Logger.info("no start date, no entries, skipping chart");
          return;
        }

        chart.setTitle(i18n.tr("Saldo-Verlauf seit {0}", HBCI.DATEFORMAT.format(date)));

        if (k == null) // wir zeichnen einen Stacked-Graph ueber alle Konten
        {
          DBIterator it = Settings.getDBService().createList(Konto.class);
          ChartDataSaldoSumme s = new ChartDataSaldoSumme();
          while (it.hasNext()) {
            ChartDataSaldoVerlauf v = new ChartDataSaldoVerlauf((Konto) it.next(), date);
            chart.addData(v);
            s.add(v.getData());
          }

          ChartDataSaldoTrend t = new ChartDataSaldoTrend();
          t.add(s.getData());
          chart.addData(s);
          chart.addData(t);
        } else // Ansonsten nur fuer eine
        {
          ChartDataSaldoVerlauf s = new ChartDataSaldoVerlauf(k, date);
          ChartDataSaldoTrend t = new ChartDataSaldoTrend();
          t.add(s.getData());
          chart.addData(s);
          chart.addData(t);
        }

        if (event != null) chart.redraw(); // nur neu laden, wenn via Select ausgeloest

        kPrev = k;
        startPrev = start;
      } catch (Exception e) {
        Logger.error("unable to redraw chart", e);
        Application.getMessagingFactory()
            .sendMessage(
                new StatusBarMessage(
                    i18n.tr("Fehler beim Aktualisieren des Saldo-Verlaufs"),
                    StatusBarMessage.TYPE_ERROR));
      }
    }