/** @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 #2
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;
  }