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