/**
  * @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 {
   DBIterator list = konto.getProtokolle();
   if (from != null)
     list.addFilter(
         "datum >= ?", new Object[] {new java.sql.Date(DateUtil.startOfDay(from).getTime())});
   if (to != null)
     list.addFilter(
         "datum <= ?", new Object[] {new java.sql.Date(DateUtil.endOfDay(to).getTime())});
   if (text != null && text.length() > 0) {
     list.addFilter("LOWER(kommentar) like ?", new Object[] {"%" + text.toLowerCase() + "%"});
   }
   return list;
 }
  /**
   * 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.hbci.gui.chart.ChartData#getData() */
  public List getData() throws RemoteException {
    if (this.data != null) return this.data;

    // Wir holen uns erstmal alle Umsaetze im Zeitraum
    DBIterator list = UmsatzUtil.getUmsaetze();
    if (this.konto != null) list.addFilter("konto_id = " + this.konto.getID());

    list.addFilter("valuta >= ?", new Object[] {new java.sql.Date(start.getTime())});

    // Jetzt kommt die Homogenisierung ;)
    // Wir brauchen genau einen Messwert pro Tag. Das ist wichtig,
    // damit auch unterschiedliche Konten in einem Chart ueberlagernd
    // angezeigt werden koennen. Nehmen wir jetzt einfach die Umsaetze
    // aus der DB, haben wir womoeglich nicht fuer jeden Tag einen
    // Messwert, weil nicht genuegend Umsaetze vorhanden sind. Effekt:
    // In Konto A haben wir 10 Umsaetze, in Konto B aber 20. Wir haben
    // fuer Konto B also Messpunkte, zu denen in Konto A kein korrelierender
    // Wert existiert. Sowas kann man sauber nicht zeichnen. Daher iterieren
    // wir jetzt tageweise ueber die angegebene Zeitspanne. Fuer jeden Tag
    // schauen wir, ob wir einen Umsatz haben. Liegt keiner vor, nehmen
    // wir den letzten Umsatz, der vor diesem Tag liegt, da der dort
    // angegebene Saldo ja zum gesuchten Tag noch gilt.

    // BUGZILLA 1036
    double startSaldo = 0.0d;
    if (this.konto != null)
      startSaldo =
          this.konto.getNumUmsaetze() > 0
              ? KontoUtil.getAnfangsSaldo(this.konto, start)
              : this.konto.getSaldo();

    SaldoFinder finder = new SaldoFinder(list, startSaldo);
    this.data = new ArrayList<Saldo>();

    Calendar cal = Calendar.getInstance();
    cal.setTime(start);
    Date end = DateUtil.endOfDay(new Date());

    while (!start.after(end)) {
      Saldo s = new Saldo(start, finder.get(start));
      this.data.add(s);

      // Und weiter zum naechsten Tag
      cal.add(Calendar.DAY_OF_MONTH, 1);
      start = cal.getTime();
    }
    return this.data;
  }
Example #5
0
    /** @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));
      }
    }
Example #6
0
  /**
   * Erzeugt eine Liste von Salden fuer das angegebene Konto im angegebenen Zeitraum. Die Liste
   * enthaelt hierbei fuer jeden Tag einen Wert (auch wenn an diesem Tag keine Zahlungsvorgaenge
   * stattfanden - in dem Fall besitzt der Wert den Saldo des Vortages), kann daher also 1:1 auf
   * eine Chart-Grafik gemappt werden.
   *
   * @param k das Konto. Optional. Ist keines angegeben, wird eine Prognose ueber alle Konten
   *     erstellt.
   * @param from Beginn des Zeitraumes. Ist keiner angegeben, beginnt die Auswertung beim heutigen
   *     Tag.
   * @param to Ende des Zeitraumes. Ist keines angegeben, endet die Auswertung 1 Jahr nach Beginn
   *     des Zeitraumes.
   * @return die Liste der Salden.
   * @throws RemoteException
   */
  public static List<Value> create(Konto k, Date from, Date to) throws RemoteException {
    ////////////////////////////////////////////////////////////////////////////
    // Start- und End-Datum vorbereiten
    if (from == null) from = new Date();

    if (to == null) {
      Calendar cal = Calendar.getInstance();
      cal.setTime(from);
      cal.add(Calendar.YEAR, 1);
      to = cal.getTime();
    }

    from = DateUtil.startOfDay(from);
    to = DateUtil.endOfDay(to);
    //
    ////////////////////////////////////////////////////////////////////////////

    ////////////////////////////////////////////////////////////////////////////
    // Schritt 1: Die Daten aller Provider in einer Liste zusammenfassen.
    // Das sind erstmal noch keine Salden sondern nur die Geldbewegungen
    TreeMap<Date, Value> dates = new TreeMap<Date, Value>();
    List<ForecastProvider> providers = getProviders();
    for (ForecastProvider p : providers) {
      if (!isEnabled(p)) continue;

      try {
        List<Value> values = p.getData(k, from, to);
        for (Value v : values) {
          // Haben wir den Tag schon?
          Value existing = dates.get(v.getDate());
          if (existing != null) // haben wir schon. Dann dazu addieren
          {
            existing.setValue(existing.getValue() + v.getValue());
            continue;
          }

          // haben wir noch nicht. Also neu anlegen
          dates.put(v.getDate(), v);
        }
      } catch (Exception e) {
        Logger.error(
            "unable to calculate data from forecast provider \"" + p.getName() + "\", skipping", e);
      }
    }
    //
    ////////////////////////////////////////////////////////////////////////////

    ////////////////////////////////////////////////////////////////////////////
    // Schritt 2: Start-Saldo ermitteln
    double startSaldo = 0.0d;
    if (k != null)
      startSaldo = k.getNumUmsaetze() > 0 ? KontoUtil.getAnfangsSaldo(k, from) : k.getSaldo();
    //
    ////////////////////////////////////////////////////////////////////////////

    ////////////////////////////////////////////////////////////////////////////
    // Schritt 3: Salden draus machen - hierzu addieren wir die Werte jeweils auf
    List<Value> salden = new LinkedList<Value>();
    double prev = startSaldo;
    for (Value v : dates.values()) {
      Value newValue = new Value(v.getDate(), v.getValue() + prev);
      salden.add(newValue);
      prev = newValue.getValue();
    }
    //
    ////////////////////////////////////////////////////////////////////////////

    ////////////////////////////////////////////////////////////////////////////
    // Schritt 4: Homogenisieren, sodass wir fuer jeden Tag einen Wert haben.
    List<Value> result = new LinkedList<Value>();
    SaldoFinder finder = new SaldoFinder(salden, startSaldo);

    // Iterieren ueber den Zeitraum.
    Calendar cal = Calendar.getInstance();
    cal.setTime(from);

    while (!from.after(to)) {
      Value v = new Value(from, finder.get(from));
      result.add(v);

      // Und weiter zum naechsten Tag
      cal.add(Calendar.DATE, 1);
      from = cal.getTime();
    }
    //
    ////////////////////////////////////////////////////////////////////////////

    return result;
  }