1976 lines
54 KiB
C++
1976 lines
54 KiB
C++
/*
|
|
Copyright 2010-2016 Grégory Soutadé
|
|
|
|
This file is part of KissCount.
|
|
|
|
KissCount is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
KissCount is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with KissCount. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <fstream>
|
|
#include <iostream>
|
|
|
|
#include <QString>
|
|
#include <QMessageBox>
|
|
#include <QSqlQuery>
|
|
#include <QSqlError>
|
|
#include <QVariant>
|
|
#include <QSqlRecord>
|
|
#include <QCryptographicHash>
|
|
|
|
#include "Database.hpp"
|
|
|
|
Database::Database(const char* filename, KissCount* kiss) : _kiss(kiss)
|
|
{
|
|
std::ifstream bdd_file;
|
|
|
|
QString sPath = GetDatabaseHome() + GetDatabaseFile();
|
|
|
|
_db = QSqlDatabase::addDatabase("QSQLITE");
|
|
|
|
if (filename)
|
|
{
|
|
bdd_file.open(filename, std::ifstream::in);
|
|
|
|
if (!bdd_file.good())
|
|
{
|
|
QMessageBox::critical(0, _("Error"), _("Unable to open database"));
|
|
throw std::string("Unable to open ") + filename;
|
|
}
|
|
|
|
_db.setDatabaseName(filename);
|
|
|
|
if (!_db.open())
|
|
{
|
|
QMessageBox::critical(0, _("Error"), _("Unable to open database"));
|
|
throw std::string("Unable to open ") + filename;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If default BDD file, assume this can be the first load
|
|
bdd_file.open(sPath.toStdString().c_str(), std::ifstream::in);
|
|
|
|
if (!bdd_file.good())
|
|
{
|
|
CreateDatabase();
|
|
}
|
|
else
|
|
{
|
|
_db.setDatabaseName(sPath);
|
|
|
|
if (!_db.open())
|
|
{
|
|
QMessageBox::critical(0, _("Error"), _("Unable to open database"));
|
|
throw std::string("Unable to open ") + sPath.toStdString();
|
|
}
|
|
}
|
|
}
|
|
|
|
bdd_file.close();
|
|
|
|
CheckDatabaseVersion();
|
|
}
|
|
|
|
void Database::CreateDatabase()
|
|
{
|
|
QFile init_script(INIT_SCRIPT);
|
|
QString sPath = GetDatabaseHome() + GetDatabaseFile();
|
|
QDir dirname( GetDatabaseHome());
|
|
QFile file(sPath);
|
|
QString message;
|
|
|
|
message = _("A new database will be created, continue ?");
|
|
if (QMessageBox::question(0, "KissCount", message, QMessageBox::Yes|QMessageBox::No) == QMessageBox::No)
|
|
throw std::string("Abort") ;
|
|
|
|
if (!init_script.exists() || !init_script.open(QIODevice::ReadOnly | QIODevice::Text))
|
|
{
|
|
QMessageBox::critical(0, _("Error"), INIT_SCRIPT + _(" not found, aborting"));
|
|
throw "init.sql not found, aborting";
|
|
}
|
|
if (!dirname.exists() && !dirname.mkdir(dirname.absolutePath()))
|
|
{
|
|
QMessageBox::critical(0, _("Error"), _("Unable to Create ") + dirname.absolutePath() );
|
|
throw std::string("Unable to create ") + dirname.absolutePath().toStdString();
|
|
}
|
|
|
|
if (!file.exists() && !file.open(QIODevice::WriteOnly | QIODevice::Truncate))
|
|
{
|
|
QMessageBox::critical(0, _("Error"), _("Unable to Create ") + QString(sPath));
|
|
throw std::string("Unable to create ") + sPath.toStdString();
|
|
}
|
|
|
|
file.close();
|
|
|
|
_db.setDatabaseName(sPath);
|
|
|
|
if (!_db.open())
|
|
{
|
|
QMessageBox::critical(0, _("Error"), _("Unable to open Database"));
|
|
throw std::string("Unable to open ") + sPath.toStdString();
|
|
}
|
|
|
|
while (!init_script.atEnd())
|
|
{
|
|
QByteArray line = init_script.readLine().trimmed();
|
|
QSqlQuery query;
|
|
|
|
if (line.isEmpty() || line.startsWith("--")) continue;
|
|
|
|
// if (!query.isValid())
|
|
// {
|
|
// std::cout << QString(line).toStdString() << " is invalid !\n" ;
|
|
// continue;
|
|
// }
|
|
|
|
if (!query.exec(QString(line)))
|
|
{
|
|
QMessageBox::critical(0, _("Error"), _("Error creating original database"));
|
|
init_script.close();
|
|
file.remove();
|
|
std::cout << QString(line).toStdString() << " is invalid !\n" ;
|
|
throw QString(line);
|
|
}
|
|
}
|
|
|
|
init_script.close();
|
|
}
|
|
|
|
|
|
QString Database::HashPassword(const QString& password)
|
|
{
|
|
return QCryptographicHash::hash(password.toUtf8(), QCryptographicHash::Sha1).toHex();
|
|
}
|
|
|
|
std::list<QString> Database::GetUsers()
|
|
{
|
|
std::list<QString> res;
|
|
QSqlQuery query(_db);
|
|
|
|
EXECUTE_SQL_QUERY(QString("SELECT name FROM user ORDER BY name"), res);
|
|
|
|
while (query.next())
|
|
res.push_back(query.value(0).toString());
|
|
|
|
return res;
|
|
}
|
|
|
|
bool Database::IsValidUser(const QString& user, const QString& password)
|
|
{
|
|
QSqlQuery query(_db);
|
|
|
|
query.prepare("SELECT name FROM user WHERE name=:id AND password=:password");
|
|
query.bindValue(":id", user);
|
|
query.bindValue(":password", HashPassword(password));
|
|
EXECUTE_PREPARED_SQL_QUERY(false);
|
|
|
|
return query.next();
|
|
}
|
|
|
|
static inline void fillOperation(Operation* op, const QSqlRecord& set)
|
|
{
|
|
op->id = set.value("id").toInt();
|
|
op->parent = set.value("parent").toInt();
|
|
op->account = set.value("account").toInt();
|
|
op->day = set.value("day").toInt();
|
|
op->month = set.value("month").toInt();
|
|
op->year = set.value("year").toInt();
|
|
op->amount = set.value("amount").toInt();
|
|
op->description = set.value("description").toString();
|
|
op->category = set.value("category").toInt();
|
|
op->tag = set.value("tag").toInt();
|
|
op->fix_cost = set.value("fix_cost").toBool();
|
|
op->checked = set.value("checked").toBool();
|
|
op->transfert = set.value("transfert").toInt();
|
|
op->formula = set.value("formula").toString();
|
|
op->meta = set.value("meta").toBool();
|
|
op->_virtual = set.value("virtual").toBool();
|
|
}
|
|
|
|
static inline void fillAccount(Account* account, const QSqlRecord& set)
|
|
{
|
|
account->id = set.value("id").toInt();
|
|
account->name = set.value("name").toString();
|
|
account->number = set.value("number").toString();
|
|
account->shared = set.value("shared").toBool();
|
|
account->blocked = set.value("blocked").toBool();
|
|
account->_default = set.value("default_account").toBool();
|
|
account->_virtual = set.value("virtual").toBool();
|
|
account->is_owner = true;
|
|
account->hidden = set.value("hidden").toBool();
|
|
account->start_date = set.value("start").toDate();
|
|
account->end_date = set.value("end").toDate();
|
|
}
|
|
|
|
static inline void fillCategory(Category* category, const QSqlRecord& set)
|
|
{
|
|
category->id = set.value("id").toInt();
|
|
category->parent = set.value("parent").toInt();
|
|
category->name = set.value("name").toString();
|
|
category->backcolor = QColor(set.value("backcolor").toString());
|
|
category->forecolor = QColor(set.value("forecolor").toString());
|
|
category->font = set.value("font").toString();
|
|
category->fix_cost = set.value("fix_cost").toBool();
|
|
}
|
|
|
|
static inline void fillTag(Tag* tag, const QSqlRecord& set)
|
|
{
|
|
tag->id = set.value("id").toInt();
|
|
tag->name = set.value("name").toString();
|
|
}
|
|
|
|
User* Database::LoadUser(const QString& name)
|
|
{
|
|
User* user;
|
|
Account account;
|
|
Category category;
|
|
Tag tag;
|
|
ImportPattern importPattern;
|
|
QString req;
|
|
QSqlRecord set;
|
|
QSqlQuery query(_db);
|
|
|
|
std::vector<Account>::iterator it;
|
|
|
|
query.prepare("SELECT * FROM user WHERE name=:name");
|
|
query.bindValue(":name", name);
|
|
EXECUTE_PREPARED_SQL_QUERY(0);
|
|
|
|
if (!query.next())
|
|
return 0;
|
|
|
|
user = new User(this);
|
|
|
|
set = query.record();
|
|
|
|
user->_id = set.value("id").toInt();
|
|
user->_name = set.value("name").toString();
|
|
user->_password = "" ; // Security reasons set.value("password").toString();
|
|
|
|
query.clear();
|
|
|
|
req = QString("SELECT * FROM account WHERE user='%1' ORDER BY default_account DESC, hidden, blocked, virtual, name ASC").arg(user->_id);
|
|
|
|
EXECUTE_SQL_QUERY_WITH_CODE(req, 0, {delete user;}, {delete user;});
|
|
|
|
while (query.next())
|
|
{
|
|
set = query.record();
|
|
fillAccount(&account, set);
|
|
user->_accounts.push_back(account);
|
|
}
|
|
|
|
query.clear();
|
|
|
|
req = QString("SELECT * FROM account WHERE id IN (SELECT account FROM shared_account WHERE user='%1') ORDER BY default_account DESC, hidden, blocked, virtual, name ASC").arg(user->_id);
|
|
|
|
EXECUTE_SQL_QUERY_WITH_CODE(req, 0, {delete user;}, {delete user;});
|
|
|
|
while (query.next())
|
|
{
|
|
set = query.record();
|
|
fillAccount(&account, set);
|
|
account.is_owner = false;
|
|
user->_accounts.push_back(account);
|
|
}
|
|
|
|
query.clear();
|
|
|
|
if (!user->_accounts.empty())
|
|
{
|
|
it = user->_accounts.begin();
|
|
req = "SELECT DISTINCT year FROM operation WHERE account IN('" + QString::number(it->id);
|
|
it++;
|
|
for (;it != user->_accounts.end(); it++)
|
|
{
|
|
req += "', '" + QString::number(it->id) ;
|
|
}
|
|
req += "')";
|
|
req += " OR user='" + QString::number(user->_id) + "'";
|
|
req += " ORDER BY year ASC";
|
|
|
|
EXECUTE_SQL_QUERY_WITH_CODE(req, 0, {delete user;}, {delete user;});
|
|
|
|
while (query.next())
|
|
{
|
|
set = query.record();
|
|
user->_operations[set.value("year").toInt()] = 0;
|
|
}
|
|
}
|
|
|
|
req = QString("SELECT * FROM category WHERE user='%1' ORDER BY fix_cost DESC, name ASC").arg(user->_id);
|
|
EXECUTE_SQL_QUERY_WITH_CODE(req, 0, {delete user;}, {delete user;});
|
|
|
|
while (query.next())
|
|
{
|
|
set = query.record();
|
|
fillCategory(&category, set);
|
|
|
|
user->_categories.push_back(category);
|
|
user->_categoriesFonts.push_back(_kiss->ExtractFont(category.font));
|
|
}
|
|
|
|
query.clear();
|
|
|
|
req = QString("SELECT * FROM tag WHERE user='%1' ORDER BY name ASC").arg(user->_id);
|
|
EXECUTE_SQL_QUERY_WITH_CODE(req, 0, {delete user;}, {delete user;});
|
|
|
|
while (query.next())
|
|
{
|
|
set = query.record();
|
|
fillTag(&tag, set);
|
|
|
|
user->_tags.push_back(tag);
|
|
}
|
|
|
|
query.clear();
|
|
|
|
req = QString("SELECT name, value FROM preference WHERE user='%1' ORDER BY value ASC").arg(user->_id);
|
|
EXECUTE_SQL_QUERY_WITH_CODE(req, 0, {delete user;}, {delete user;});
|
|
|
|
while (query.next())
|
|
{
|
|
set = query.record();
|
|
user->_preferences[set.value("name").toString()] = set.value("value").toString();
|
|
}
|
|
|
|
query.clear();
|
|
|
|
req = QString("SELECT * FROM import_pattern WHERE user='%1'").arg(user->_id);
|
|
EXECUTE_SQL_QUERY_WITH_CODE(req, 0, {delete user;}, {delete user;});
|
|
|
|
while (query.next())
|
|
{
|
|
set = query.record();
|
|
importPattern.pattern = set.value("pattern").toString();
|
|
importPattern.account = set.value("account").toInt();
|
|
importPattern.category = set.value("category").toInt();
|
|
|
|
user->_importPatterns[set.value("description").toString()] = importPattern;
|
|
}
|
|
|
|
query.clear();
|
|
|
|
return user;
|
|
}
|
|
|
|
void Database::LoadYear(User* user, int year)
|
|
{
|
|
QSqlRecord set;
|
|
QString req;
|
|
std::vector<Account>::iterator it;
|
|
QSqlQuery query(_db);
|
|
|
|
if (user->_operations[year] == 0)
|
|
user->_operations[year] = new std::map<unsigned int, std::vector<Operation> >();
|
|
|
|
if (!user->_accounts.size()) return;
|
|
|
|
it = user->_accounts.begin();
|
|
req = "SELECT * FROM operation WHERE (account IN('" + QString::number(it->id);
|
|
it++;
|
|
for (;it != user->_accounts.end(); it++)
|
|
{
|
|
req += "', '" + QString::number(it->id) ;
|
|
}
|
|
req += "')";
|
|
req += " OR user='" + QString::number(user->_id) + "')";
|
|
req += " AND year='" + QString::number(year) + "'";
|
|
req += " ORDER BY fix_cost DESC, year, month ASC, day ";
|
|
req += user->_preferences["operation_order"];
|
|
|
|
EXECUTE_SQL_QUERY(req, );
|
|
|
|
while (query.next())
|
|
{
|
|
Operation op;
|
|
set = query.record();
|
|
fillOperation(&op, set);
|
|
(*user->_operations[op.year])[op.month].push_back(op);
|
|
}
|
|
|
|
user->ResolveGroups(year);
|
|
query.clear();
|
|
}
|
|
|
|
int Database::GetAccountAmount(int id, int month, int year, bool* had_value, bool create_if_not_exsits)
|
|
{
|
|
QSqlRecord set;
|
|
QString req;
|
|
int res = 0;
|
|
QSqlQuery query(_db);
|
|
|
|
req = QString("SELECT amount FROM account_amount WHERE account='%1' AND month='%2' AND year='%3'")
|
|
.arg(QString::number(id), QString::number(month), QString::number(year)) ;
|
|
|
|
EXECUTE_SQL_QUERY(req, 0);
|
|
|
|
if (query.next())
|
|
{
|
|
set = query.record();
|
|
res = set.value("amount").toInt();
|
|
if (had_value)
|
|
*had_value = true;
|
|
}
|
|
else
|
|
{
|
|
if (create_if_not_exsits)
|
|
SetAccountAmount(id, month, year, 0);
|
|
if (had_value)
|
|
*had_value = false;
|
|
}
|
|
|
|
query.clear();
|
|
|
|
return res;
|
|
}
|
|
|
|
int Database::CalcAccountAmount(int id, int month, int year, bool* had_values)
|
|
{
|
|
QSqlRecord set;
|
|
QString req;
|
|
int res = 0;
|
|
QSqlQuery query(_db);
|
|
|
|
req = QString("SELECT SUM(id) AS id, SUM(amount) AS amount FROM operation WHERE account='%1' AND month='%2' AND year='%3' AND meta='0'").
|
|
arg(QString::number(id), QString::number(month), QString::number(year)) ;
|
|
|
|
EXECUTE_SQL_QUERY(req, 0);
|
|
|
|
if (query.next())
|
|
{
|
|
set = query.record();
|
|
res = set.value("amount").toInt();
|
|
if (had_values)
|
|
*had_values = set.value("id").toInt() > 0 ;
|
|
}
|
|
else
|
|
{
|
|
if (had_values)
|
|
*had_values = false;
|
|
}
|
|
|
|
query.clear();
|
|
|
|
return res;
|
|
}
|
|
|
|
bool Database::GetOperation(int id, Operation* op)
|
|
{
|
|
QSqlRecord set;
|
|
QString req;
|
|
QSqlQuery query(_db);
|
|
|
|
req = QString("SELECT * FROM operation WHERE id='%1'").arg(QString::number(id));
|
|
|
|
EXECUTE_SQL_QUERY(req, false);
|
|
|
|
if (!query.next()) return false;
|
|
|
|
set = query.record();
|
|
|
|
fillOperation(op, set);
|
|
|
|
return true;
|
|
}
|
|
|
|
void Database::LinkOrUnlinkOperation(User* user, Operation& op)
|
|
{
|
|
Operation linked;
|
|
QString req, v;
|
|
QSqlRecord set;
|
|
Account account, account2;
|
|
bool _virtual;
|
|
QSqlQuery query(_db);
|
|
|
|
if (op.meta) return;
|
|
|
|
account = user->GetAccount(op.account);
|
|
|
|
if (op.transfert)
|
|
{
|
|
// No one or not linked
|
|
if (!GetOperation(op.transfert, &linked) || op.description != linked.description || op.amount != -linked.amount || op.account == linked.account)
|
|
{
|
|
op._virtual = account._virtual;
|
|
req = QString("UPDATE operation SET transfert='', virtual='%1' WHERE id='%2'").arg(op._virtual?"1":"0", op.id);
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
op.transfert = 0;
|
|
return;
|
|
}
|
|
}
|
|
// Not Linked
|
|
else
|
|
{
|
|
req = QString("SELECT id FROM operation WHERE transfert='%1'").arg(op.id);
|
|
|
|
EXECUTE_SQL_QUERY(req, );
|
|
|
|
if (query.next())
|
|
{
|
|
op._virtual = account._virtual;
|
|
set = query.record();
|
|
req = QString("UPDATE operation SET transfert='', virtual='%1' WHERE id='%2'").arg(op._virtual?"1":"0", set.value("id").toString());
|
|
query.clear();
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
}
|
|
else
|
|
query.clear();
|
|
|
|
req = QString("SELECT id, account FROM operation WHERE description=\"%1\" AND month='%2' AND year='%3' AND amount='%4' AND meta='0' AND account !='%5' AND transfert=''")
|
|
.arg(op.description, QString::number(op.month), QString::number(op.year), v.sprintf("%d", -op.amount), QString::number(op.account));
|
|
|
|
EXECUTE_SQL_QUERY(req, );
|
|
|
|
// Don't need to link
|
|
if (!query.next()) return ;
|
|
|
|
set = query.record();
|
|
|
|
// Link
|
|
linked.id = set.value("id").toInt();
|
|
|
|
op.transfert = linked.id;
|
|
|
|
account2 = user->GetAccount(set.value("account").toInt());
|
|
|
|
_virtual = account._virtual || account2._virtual;
|
|
|
|
query.clear();
|
|
|
|
req = QString("UPDATE operation SET transfert='%1', virtual='%2' WHERE id='%3'")
|
|
.arg((linked.id) ? QString::number(linked.id) : "", QString::number(_virtual), QString::number(op.id));
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
query.clear();
|
|
|
|
req = QString("UPDATE operation SET transfert='%1', virtual='%2' WHERE id='%3'")
|
|
.arg((op.id) ? QString::number(op.id) : "", QString::number(_virtual), QString::number(linked.id));
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
op._virtual = _virtual;
|
|
|
|
query.clear();
|
|
}
|
|
}
|
|
|
|
void Database::UpdateOperation(User* user, Operation& op, bool checkTransfert)
|
|
{
|
|
QString req, v;
|
|
QSqlQuery query(_db);
|
|
|
|
if (checkTransfert)
|
|
LinkOrUnlinkOperation(user, op);
|
|
|
|
ESCAPE_CHARS(op.description);
|
|
|
|
req = "UPDATE operation SET parent='%1', account='%2', year='%3', month='%4', day='%5', amount='%6', description=:description, category='%8', tag='%9'" ;
|
|
req = req.arg((op.parent) ? QString::number(op.parent) : "", QString::number(op.account), QString::number(op.year), QString::number(op.month),
|
|
QString::number(op.day), v.sprintf("%d", op.amount), QString::number(op.category), QString::number(op.tag));
|
|
req += ", fix_cost='%1', checked='%2', transfert='%3', meta='%4', virtual='%5', formula=:formula WHERE id='%7'";
|
|
req = req.arg(QString::number(op.fix_cost), QString::number(op.checked), (op.transfert) ? QString::number(op.transfert): "",
|
|
QString::number(op.meta), QString::number(op._virtual), QString::number(op.id));
|
|
|
|
query.prepare(req);
|
|
query.bindValue(":description", op.description);
|
|
query.bindValue(":formula", op.formula);
|
|
|
|
EXECUTE_PREPARED_SQL_UPDATE();
|
|
|
|
if (checkTransfert)
|
|
LinkOrUnlinkOperation(user, op);
|
|
}
|
|
|
|
int Database::AddOperation(User* user, Operation& op, bool checkTransfert)
|
|
{
|
|
QString req, v;
|
|
QSqlRecord set;
|
|
QSqlQuery query(_db);
|
|
|
|
|
|
ESCAPE_CHARS(op.description);
|
|
|
|
req = "INSERT INTO operation ('user', 'parent', 'account', 'year', 'month', 'day', 'amount', 'description', 'category', 'tag', 'fix_cost', 'formula', 'transfert', 'meta', 'virtual', 'checked') VALUES ('%1', '%2', '%3', '%4', '%5', '%6', '%7', :description" ;
|
|
req = req.arg(QString::number(user->_id), (op.parent) ? QString::number(op.parent): "", QString::number(op.account), QString::number(op.year),
|
|
QString::number(op.month), QString::number(op.day), v.sprintf("%d", op.amount));
|
|
req += ", '%1', '%2', '%3', :formula, '%4', '%5', '%6', '%7')";
|
|
req = req.arg(QString::number(op.category), QString::number(op.tag), QString::number(op.fix_cost), (op.transfert) ? QString::number(op.transfert): "",
|
|
QString::number(op.meta), QString::number(op._virtual), QString::number(op.checked));
|
|
|
|
query.prepare(req);
|
|
query.bindValue(":description", op.description);
|
|
query.bindValue(":formula", op.formula);
|
|
|
|
if (!query.exec())
|
|
{
|
|
QMessageBox::critical(0, _("Error"), _("Update failed !\n") + req);
|
|
return 0;
|
|
}
|
|
|
|
op.id = query.lastInsertId().toInt();
|
|
|
|
if (checkTransfert)
|
|
LinkOrUnlinkOperation(user, op);
|
|
|
|
return op.id;
|
|
}
|
|
|
|
void Database::DeleteOperation(User* user, Operation& op)
|
|
{
|
|
QSqlQuery query(_db);
|
|
QString req = QString("DELETE FROM operation WHERE id='%1'").arg(op.id);
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
LinkOrUnlinkOperation(user, op);
|
|
}
|
|
|
|
void Database::DeleteOperations(User* user, int month, int year)
|
|
{
|
|
QString req;
|
|
std::vector<Account>::iterator it;
|
|
|
|
it = user->_accounts.begin();
|
|
req = "DELETE FROM account_amount WHERE account IN('" + QString::number(it->id);
|
|
it++;
|
|
for (;it != user->_accounts.end(); it++)
|
|
{
|
|
req += "', '" + QString::number(it->id) ;
|
|
}
|
|
req += "')";
|
|
req += " AND year='" + QString::number(year) + "'";
|
|
if (month != -1)
|
|
req += " AND month='" + QString::number(month) + "'";
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
it = user->_accounts.begin();
|
|
req = "DELETE FROM operation WHERE (account IN('" + QString::number(it->id);
|
|
it++;
|
|
for (;it != user->_accounts.end(); it++)
|
|
{
|
|
req += "', '" + QString::number(it->id) ;
|
|
}
|
|
req += "')";
|
|
req += " OR user='" + QString::number(user->_id) + "')";
|
|
req += " AND year='" + QString::number(year) + "'";
|
|
if (month != -1)
|
|
req += " AND month='" + QString::number(month) + "'";
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
}
|
|
|
|
bool Database::LoadOperation(User* user, int id)
|
|
{
|
|
QSqlRecord set;
|
|
QString req;
|
|
bool ret = false;
|
|
std::vector<Operation>::iterator it;
|
|
QSqlQuery query(_db);
|
|
|
|
req = QString("SELECT * FROM operation WHERE id='%1'").arg(id);
|
|
|
|
EXECUTE_SQL_QUERY(req, false);
|
|
|
|
if (query.next())
|
|
{
|
|
Operation op;
|
|
set = query.record();
|
|
fillOperation(&op, set);
|
|
|
|
if (user->_operations[op.year])
|
|
{
|
|
for (it = (*user->_operations[op.year])[op.month].begin();
|
|
it != (*user->_operations[op.year])[op.month].end();
|
|
it++)
|
|
{
|
|
if (!op.fix_cost && it->fix_cost) continue;
|
|
if (op.fix_cost && !it->fix_cost)
|
|
{
|
|
it--;
|
|
break;
|
|
}
|
|
if (it->day > op.day)
|
|
{
|
|
it--;
|
|
break;
|
|
}
|
|
}
|
|
if (it == (*user->_operations[op.year])[op.month].end())
|
|
(*user->_operations[op.year])[op.month].push_back(op);
|
|
else
|
|
(*user->_operations[op.year])[op.month].insert(it, op);
|
|
// if (op.fix_cost)
|
|
// else
|
|
// (*user->_operations[op.year])[op.month].push_back(op);
|
|
ret = true;
|
|
}
|
|
}
|
|
|
|
query.clear();
|
|
|
|
return ret;
|
|
}
|
|
|
|
// We may not have access to all operations if we have a shared account
|
|
int Database::MetaAmount(int id)
|
|
{
|
|
QSqlRecord set;
|
|
QString req;
|
|
int res = 0;
|
|
QSqlQuery query(_db);
|
|
|
|
req = QString("SELECT SUM(amount) as amount FROM operation WHERE parent='%1'").arg(id);
|
|
|
|
EXECUTE_SQL_QUERY(req, false);
|
|
|
|
if (query.next())
|
|
{
|
|
set = query.record();
|
|
res = set.value("amount").toInt();
|
|
}
|
|
|
|
query.clear();
|
|
|
|
return res;
|
|
}
|
|
|
|
// Idem
|
|
int Database::MetaPositiveAmount(int id)
|
|
{
|
|
QSqlRecord set;
|
|
QString req;
|
|
int res = 0;
|
|
QSqlQuery query(_db);
|
|
|
|
req = QString("SELECT SUM(amount) as amount FROM operation WHERE amount > 0 AND parent='%1'").arg(id);
|
|
|
|
EXECUTE_SQL_QUERY(req, false);
|
|
|
|
if (query.next())
|
|
{
|
|
set = query.record();
|
|
res = set.value("amount").toInt();
|
|
}
|
|
|
|
query.clear();
|
|
|
|
return res;
|
|
}
|
|
|
|
void Database::SetAccountAmount(int accountId, int month, int year, int amount)
|
|
{
|
|
QString req, v;
|
|
QSqlQuery query(_db);
|
|
|
|
req = "INSERT or REPLACE INTO account_amount ('account', 'year', 'month', 'amount') VALUES ('%1', '%2', '%3', '%4')" ;
|
|
req = req.arg(QString::number(accountId), QString::number(year), QString::number(month), v.sprintf("%d", amount));
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
}
|
|
|
|
int Database::AddAccount(User* user, Account& ac)
|
|
{
|
|
QString req;
|
|
QSqlQuery query(_db);
|
|
int id;
|
|
|
|
req = "INSERT INTO account ('user', 'name', 'number', 'shared', 'blocked', 'default_account', 'virtual', 'hidden') VALUES " ;
|
|
req += "('%1', '%2', '%3', '%4', '%5', '%6', '%7', '%8')";
|
|
req = req.arg(QString::number(user->_id), ac.name, ac.number, QString::number(ac.shared), QString::number(ac.blocked),
|
|
QString::number(ac._default), QString::number(ac._virtual), QString::number(ac.hidden));
|
|
|
|
if (!query.exec(req))
|
|
{
|
|
QMessageBox::critical(0, _("Error"), _("Update failed !\n") + req);
|
|
std::cerr << __FUNCTION__ << "\n" ;
|
|
std::cerr << req.toStdString() << "\n" ;
|
|
std::cerr << query.lastError().text().toStdString() << "\n" ;
|
|
return 0;
|
|
}
|
|
|
|
id = query.lastInsertId().toInt();
|
|
req = "UPDATE account SET start='%1', end='%2' WHERE id='%3'";
|
|
req = req.arg(ac.start_date.toString("yyyy-MM-dd"), ac.end_date.toString("yyyy-MM-dd"), QString::number(id));
|
|
|
|
EXECUTE_SQL_UPDATE(req, 0);
|
|
|
|
return id;
|
|
}
|
|
|
|
void Database::UpdateAccount(Account& ac)
|
|
{
|
|
QString req;
|
|
|
|
req = "UPDATE account SET name='%1', number='%2', shared='%3', blocked='%4', default_account='%5', virtual='%6', hidden='%7' WHERE id='%8'" ;
|
|
req = req.arg(ac.name, ac.number, QString::number(ac.shared), QString::number(ac.blocked), QString::number(ac._default),
|
|
QString::number(ac._virtual), QString::number(ac.hidden), QString::number(ac.id));
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
req = "UPDATE account SET start='%1', end='%2' WHERE id='%3'" ;
|
|
req = req.arg(ac.start_date.toString("yyyy-MM-dd"), ac.end_date.toString("yyyy-MM-dd"),
|
|
QString::number(ac.id));
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
if (!ac.shared && ac.is_owner)
|
|
{
|
|
req = QString("DELETE FROM shared_account WHERE account='%1'").arg(ac.id);
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
}
|
|
}
|
|
|
|
void Database::DeleteAccount(User* user, Account& ac, int replacement)
|
|
{
|
|
QString req;
|
|
|
|
if (ac.is_owner)
|
|
{
|
|
if (ac.shared)
|
|
{
|
|
req = QString("DELETE FROM shared_account WHERE account='%1'").arg(ac.id);
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
}
|
|
|
|
req = QString("DELETE FROM account WHERE id='%1'").arg(ac.id);
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
req = QString("DELETE FROM account_amount WHERE account='%1'").arg(ac.id);
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
req = QString("UPDATE operation SET account='%1' WHERE account='%2'").arg(QString::number(replacement), QString::number(ac.id));
|
|
// req += wxT(", transfert='0'");
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
}
|
|
else
|
|
RemoveSharedAccount(ac, user->_id);
|
|
}
|
|
|
|
void Database::AddSharedAccount(Account& ac, const QString& granted)
|
|
{
|
|
QString req;
|
|
QSqlRecord set;
|
|
QSqlQuery query(_db);
|
|
|
|
req = QString("SELECT id FROM user WHERE name=:name");
|
|
|
|
query.prepare(req);
|
|
query.bindValue(":name", granted);
|
|
|
|
EXECUTE_PREPARED_SQL_QUERY();
|
|
|
|
query.next();
|
|
|
|
set = query.record();
|
|
|
|
req = QString("INSERT INTO shared_account ('account', 'user') VALUES ('%1', '%2')").arg(QString::number(ac.id), set.value("id").toString());
|
|
|
|
query.clear();
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
if (!ac.shared)
|
|
{
|
|
ac.shared = true;
|
|
UpdateAccount(ac);
|
|
}
|
|
}
|
|
|
|
void Database::RemoveSharedAccount(Account& ac, int granted)
|
|
{
|
|
QString req;
|
|
QSqlRecord set;
|
|
QSqlQuery query(_db);
|
|
|
|
req = QString("DELETE FROM shared_account WHERE user='%1' AND account='%2'").arg(QString::number(granted), QString::number(ac.id));
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
req = QString("SELECT COUNT(user) AS cnt FROM shared_account WHERE account='%1'").arg(ac.id);
|
|
|
|
EXECUTE_SQL_QUERY(req, );
|
|
|
|
query.next();
|
|
|
|
set = query.record();
|
|
|
|
if (!set.value("cnt").toInt())
|
|
{
|
|
ac.shared = false;
|
|
UpdateAccount(ac);
|
|
}
|
|
|
|
}
|
|
|
|
int Database::AddCategory(User* user, Category& category)
|
|
{
|
|
QString req;
|
|
QString backcolor, forecolor;
|
|
QSqlQuery query(_db);
|
|
|
|
backcolor = "#" ;
|
|
backcolor += QString::number(category.backcolor.red(), 16);
|
|
backcolor += QString::number(category.backcolor.green(), 16);
|
|
backcolor += QString::number(category.backcolor.blue(), 16);
|
|
|
|
forecolor = "#" ;
|
|
forecolor += QString::number(category.forecolor.red(), 16);
|
|
forecolor += QString::number(category.forecolor.green(), 16);
|
|
forecolor += QString::number(category.forecolor.blue(), 16);
|
|
|
|
req = "INSERT INTO category ('user', 'parent', 'name', 'backcolor', 'forecolor', 'font', 'fix_cost') VALUES ('" ;
|
|
req += QString::number(user->_id) + "'";
|
|
req += ", '" + QString::number(category.parent) + "'";
|
|
req += ", :name";
|
|
req += ", '" + backcolor + "'";
|
|
req += ", '" + forecolor + "'";
|
|
req += ", '" + category.font + "'";
|
|
if (category.fix_cost)
|
|
req += ", '1'";
|
|
else
|
|
req += ", '0'";
|
|
req += ")";
|
|
|
|
query.prepare(req);
|
|
query.bindValue(":name", category.name);
|
|
|
|
if (!query.exec())
|
|
{
|
|
QMessageBox::critical(0, _("Error"), _("Update failed !\n") + req);
|
|
std::cerr << __FUNCTION__ << "\n" ;
|
|
std::cerr << req.toStdString() << "\n" ;
|
|
std::cerr << query.lastError().text().toStdString() << "\n" ;
|
|
return 0;
|
|
}
|
|
|
|
return query.lastInsertId().toInt();
|
|
}
|
|
|
|
void Database::UpdateCategory(Category& category)
|
|
{
|
|
QString req, tmp;
|
|
QString backcolor, forecolor;
|
|
QSqlQuery query(_db);
|
|
|
|
backcolor = "#" ;
|
|
tmp = QString::number(category.backcolor.red(), 16);
|
|
if (tmp.length() == 1) tmp = "0" + tmp;
|
|
backcolor += tmp;
|
|
tmp = QString::number(category.backcolor.green(), 16);
|
|
if (tmp.length() == 1) tmp = "0" + tmp;
|
|
backcolor += tmp;
|
|
tmp = QString::number(category.backcolor.blue(), 16);
|
|
if (tmp.length() == 1) tmp = "0" + tmp;
|
|
backcolor += tmp;
|
|
|
|
forecolor = "#" ;
|
|
tmp = QString::number(category.forecolor.red(), 16);
|
|
if (tmp.length() == 1) tmp = "0" + tmp;
|
|
forecolor += tmp;
|
|
tmp = QString::number(category.forecolor.green(), 16);
|
|
if (tmp.length() == 1) tmp = "0" + tmp;
|
|
forecolor += tmp;
|
|
tmp = QString::number(category.forecolor.blue(), 16);
|
|
if (tmp.length() == 1) tmp = "0" + tmp;
|
|
forecolor += tmp;
|
|
|
|
req = "UPDATE category SET" ;
|
|
req += " parent='" + QString::number(category.parent) + "'";
|
|
req += ", name=:name";
|
|
req += ", backcolor='" + backcolor + "'";
|
|
req += ", forecolor='" + forecolor + "'";
|
|
req += ", font='" + category.font + "'";
|
|
if (category.fix_cost)
|
|
req += ", fix_cost='1'";
|
|
else
|
|
req += ", fix_cost='0'";
|
|
req += " WHERE id='" + QString::number(category.id) + "'";
|
|
|
|
query.prepare(req);
|
|
query.bindValue(":name", category.name);
|
|
EXECUTE_PREPARED_SQL_UPDATE();
|
|
}
|
|
|
|
void Database::DeleteCategory(User* user, Category& category, int replacement)
|
|
{
|
|
QString req;
|
|
|
|
req = QString("DELETE FROM category WHERE id='%1'").arg(category.id);
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
req = QString("UPDATE category SET parent='' WHERE parent='%1'").arg(category.id) ;
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
req = QString("UPDATE operation SET category='%1' WHERE category='%2' AND user='%3'")
|
|
.arg(QString::number(replacement), QString::number(category.id), QString::number(user->_id));
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
if (replacement == user->_categories[0].id)
|
|
{
|
|
req = QString("UPDATE operation SET fix_cost='1' WHERE category='%1'").arg(replacement);
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
}
|
|
}
|
|
|
|
bool Database::LoadCategory(int id, const QString& name, Category& category)
|
|
{
|
|
QSqlRecord set;
|
|
QString req;
|
|
QSqlQuery query(_db);
|
|
bool ret = false ;
|
|
|
|
if (id)
|
|
{
|
|
req = QString("SELECT * FROM category WHERE id='%1'").arg(id);
|
|
EXECUTE_SQL_QUERY(req, false);
|
|
}
|
|
else
|
|
{
|
|
req = QString("SELECT * FROM category WHERE name=:name");
|
|
query.prepare(req);
|
|
query.bindValue(":name", name);
|
|
EXECUTE_PREPARED_SQL_QUERY(false);
|
|
}
|
|
|
|
if (query.next())
|
|
{
|
|
set = query.record();
|
|
fillCategory(&category, set);
|
|
ret = true;
|
|
}
|
|
|
|
query.clear();
|
|
|
|
return ret;
|
|
}
|
|
|
|
int Database::AddTag(User* user, Tag& tag)
|
|
{
|
|
QString req;
|
|
QString backcolor, forecolor;
|
|
QSqlQuery query(_db);
|
|
|
|
req = "INSERT INTO tag ('user', 'name') VALUES ('" ;
|
|
req += QString::number(user->_id) + "'";
|
|
req += ", :name";
|
|
req += ")";
|
|
|
|
query.prepare(req);
|
|
query.bindValue(":name", tag.name);
|
|
|
|
if (!query.exec())
|
|
{
|
|
QMessageBox::critical(0, _("Error"), _("Update failed !\n") + req);
|
|
std::cerr << __FUNCTION__ << "\n" ;
|
|
std::cerr << req.toStdString() << "\n" ;
|
|
std::cerr << query.lastError().text().toStdString() << "\n" ;
|
|
return 0;
|
|
}
|
|
|
|
return query.lastInsertId().toInt();
|
|
}
|
|
|
|
void Database::UpdateTag(Tag& tag)
|
|
{
|
|
QString req;
|
|
QSqlQuery query(_db);
|
|
|
|
req = "UPDATE tag SET" ;
|
|
req += "name=:name";
|
|
req += " WHERE id='" + QString::number(tag.id) + "'";
|
|
|
|
query.prepare(req);
|
|
query.bindValue(":name", tag.name);
|
|
|
|
EXECUTE_PREPARED_SQL_UPDATE();
|
|
}
|
|
|
|
void Database::DeleteTag(User* user, Tag& tag, int replacement)
|
|
{
|
|
QString req;
|
|
|
|
req = QString("DELETE FROM tag WHERE id='%1'").arg(tag.id);
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
req = QString("UPDATE operation SET tag='%1' WHERE tag='%2' AND user='%3'")
|
|
.arg(QString::number(replacement), QString::number(tag.id), QString::number(user->_id));
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
}
|
|
|
|
bool Database::LoadTag(int id, const QString& name, Tag& tag)
|
|
{
|
|
QSqlRecord set;
|
|
QString req;
|
|
QSqlQuery query(_db);
|
|
bool ret = false ;
|
|
|
|
if (id)
|
|
{
|
|
req = QString("SELECT * FROM tag WHERE id='%1'").arg(id);
|
|
EXECUTE_SQL_QUERY(req, false);
|
|
}
|
|
else
|
|
{
|
|
req = QString("SELECT * FROM tag WHERE name=:name");
|
|
query.prepare(req);
|
|
query.bindValue(":name", name);
|
|
EXECUTE_PREPARED_SQL_QUERY(false);
|
|
}
|
|
|
|
if (query.next())
|
|
{
|
|
set = query.record();
|
|
fillTag(&tag, set);
|
|
ret = true;
|
|
}
|
|
|
|
query.clear();
|
|
|
|
return ret;
|
|
}
|
|
|
|
std::map<int, std::vector<int> > Database::GetAllOperations(User* user)
|
|
{
|
|
QString req, req2, reqUnion;
|
|
QSqlRecord set;
|
|
QSqlQuery query(_db),query2(_db);
|
|
std::vector<Account>::iterator it;
|
|
std::map<int, std::vector<int> > res;
|
|
int year;
|
|
|
|
if (!user->_accounts.empty())
|
|
{
|
|
it = user->_accounts.begin();
|
|
req = "SELECT DISTINCT year FROM account_amount WHERE account IN('" + QString::number(it->id);
|
|
it++;
|
|
for (;it != user->_accounts.end(); it++)
|
|
{
|
|
req += "', '" + QString::number(it->id) ;
|
|
}
|
|
req += "')";
|
|
|
|
it = user->_accounts.begin();
|
|
req2 = "SELECT DISTINCT year FROM operation WHERE account IN('" + QString::number(it->id);
|
|
it++;
|
|
for (;it != user->_accounts.end(); it++)
|
|
{
|
|
req2 += "', '" + QString::number(it->id) ;
|
|
}
|
|
req2 += "')";
|
|
req2 += " OR user='" + QString::number(user->_id) + "'";
|
|
req2 += " ORDER BY year ASC";
|
|
|
|
reqUnion = req + " UNION " + req2;
|
|
EXECUTE_SQL_QUERY(reqUnion, res);
|
|
|
|
query2 = query;
|
|
while (query2.next())
|
|
{
|
|
set = query2.record();
|
|
|
|
year = set.value("year").toInt();
|
|
|
|
it = user->_accounts.begin();
|
|
req = "SELECT DISTINCT month FROM account_amount WHERE account IN('" + QString::number(it->id);
|
|
it++;
|
|
for (;it != user->_accounts.end(); it++)
|
|
{
|
|
req += "', '" + QString::number(it->id) ;
|
|
}
|
|
req += "')";
|
|
req += " AND year='" + QString::number(year) + "'";
|
|
|
|
it = user->_accounts.begin();
|
|
req2 = "SELECT DISTINCT month FROM operation WHERE (account IN('" + QString::number(it->id);
|
|
it++;
|
|
for (;it != user->_accounts.end(); it++)
|
|
{
|
|
req2 += "', '" + QString::number(it->id) ;
|
|
}
|
|
req2 += "')";
|
|
req2 += " OR user='" + QString::number(user->_id) + "')";
|
|
req2 += " AND year='" + QString::number(year) + "'";
|
|
req2 += " ORDER BY month ASC";
|
|
|
|
reqUnion = req + " UNION " + req2;
|
|
query.clear();
|
|
|
|
EXECUTE_SQL_QUERY(reqUnion, res);
|
|
|
|
while (query.next())
|
|
{
|
|
set = query.record();
|
|
res[year].push_back(set.value("month").toInt());
|
|
}
|
|
query.clear();
|
|
}
|
|
query2.clear();
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
void Database::GenerateMonth(User* user, int monthFrom, int yearFrom, int monthTo, int yearTo)
|
|
{
|
|
std::vector<Account>::iterator it;
|
|
QString req, v;
|
|
QSqlRecord set;
|
|
int amount;
|
|
QSqlQuery query(_db);
|
|
|
|
for (it = user->_accounts.begin(); it != user->_accounts.end(); it++)
|
|
{
|
|
amount = 0;
|
|
req = "SELECT SUM(amount) AS total FROM operation WHERE account='%1' AND year='%2' AND month='%3' AND meta='0'" ;
|
|
req = req.arg(QString::number(it->id), QString::number(yearFrom), QString::number(monthFrom));
|
|
|
|
EXECUTE_SQL_QUERY(req, );
|
|
|
|
if (query.next())
|
|
{
|
|
set = query.record();
|
|
amount += set.value("total").toInt();
|
|
}
|
|
|
|
query.clear();
|
|
|
|
req = "SELECT amount FROM account_amount WHERE account='%1' AND year='%2' AND month='%3'" ;
|
|
req = req.arg(QString::number(it->id), QString::number(yearFrom), QString::number(monthFrom));
|
|
|
|
EXECUTE_SQL_QUERY(req, );
|
|
|
|
if (query.next())
|
|
{
|
|
set = query.record();
|
|
amount += set.value("amount").toInt();
|
|
}
|
|
|
|
query.clear();
|
|
|
|
req = "INSERT INTO account_amount ('account', 'year', 'month', 'amount') VALUES " ;
|
|
req += "('%1', '%2', '%3', '%4')";
|
|
req = req.arg(QString::number(it->id), QString::number(yearTo), QString::number(monthTo), v.sprintf("%d", amount));
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
}
|
|
}
|
|
|
|
void Database::ChangePassword(User* user, const QString& password)
|
|
{
|
|
QString req;
|
|
QSqlQuery query(_db);
|
|
|
|
req = QString("UPDATE user SET password=:password WHERE name=:name");
|
|
|
|
query.prepare(req);
|
|
query.bindValue(":name", user->_name);
|
|
query.bindValue(":password", HashPassword(password));
|
|
|
|
EXECUTE_PREPARED_SQL_UPDATE();
|
|
}
|
|
|
|
bool Database::UserExists(const QString& name)
|
|
{
|
|
QSqlRecord set;
|
|
QSqlQuery query(_db);
|
|
QString req;
|
|
bool res=false;
|
|
|
|
req = QString("SELECT name FROM user WHERE name=:name");
|
|
|
|
query.prepare(req);
|
|
query.bindValue(":name", name);
|
|
|
|
EXECUTE_PREPARED_SQL_QUERY(false);
|
|
|
|
if (query.next())
|
|
res = true;
|
|
else
|
|
res = false;
|
|
|
|
query.clear();
|
|
|
|
return res;
|
|
}
|
|
|
|
void Database::ChangeName(User* user, const QString& name)
|
|
{
|
|
QString req;
|
|
QSqlQuery query(_db);
|
|
|
|
req = QString("UPDATE user SET name=:name WHERE name=:name2");
|
|
|
|
query.prepare(req);
|
|
query.bindValue(":name", name);
|
|
query.bindValue(":name2", user->_name);
|
|
|
|
EXECUTE_PREPARED_SQL_UPDATE();
|
|
}
|
|
|
|
void Database::NewUser(const QString& name)
|
|
{
|
|
QString req;
|
|
QSqlQuery query(_db);
|
|
|
|
req = QString("INSERT INTO user ('name', 'password') VALUES (:name, :password)");
|
|
|
|
query.prepare(req);
|
|
query.bindValue(":name", name);
|
|
query.bindValue(":password", HashPassword(""));
|
|
|
|
EXECUTE_PREPARED_SQL_UPDATE();
|
|
}
|
|
|
|
/*
|
|
Shared accounts not currently supported
|
|
*/
|
|
void Database::KillMe(User* user)
|
|
{
|
|
QString req;
|
|
std::vector<Account>::iterator it;
|
|
|
|
req = QString("DELETE FROM preference WHERE user='%1'").arg(user->_id);
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
if (!user->_accounts.empty())
|
|
{
|
|
for (it = user->_accounts.begin(); it != user->_accounts.end(); it++)
|
|
DeleteAccount(user, *it, 0);
|
|
|
|
it = user->_accounts.begin();
|
|
if (it->is_owner)
|
|
req = "DELETE FROM operation WHERE account IN('" + QString::number(it->id);
|
|
else
|
|
req = "DELETE FROM operation WHERE account IN('-1";
|
|
it++;
|
|
for (;it != user->_accounts.end(); it++)
|
|
{
|
|
if (it->is_owner)
|
|
req += "', '" + QString::number(it->id) ;
|
|
}
|
|
req += "')";
|
|
req += " OR (user='" + QString::number(user->_id) + "' AND account='')";
|
|
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
}
|
|
|
|
req = QString("DELETE FROM category WHERE user='%1'").arg(user->_id);
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
req = QString("DELETE FROM tag WHERE user='%1'").arg(user->_id);
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
|
|
req = QString("DELETE FROM user WHERE id='%1'").arg(user->_id);
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
}
|
|
|
|
void Database::UpdatePreference(User* user, const QString& preference)
|
|
{
|
|
QString req;
|
|
QString value = user->_preferences[preference];
|
|
QSqlQuery query(_db);
|
|
|
|
req = "INSERT or REPLACE INTO preference ('user', 'name', 'value') VALUES ('%1', '%2', '%3')" ;
|
|
req = req.arg(QString::number(user->_id), preference, value);
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
}
|
|
|
|
std::vector<Operation>* Database::Search(User* user, QString* description, QDate* dateFrom, QDate* dateTo,
|
|
int* amountFrom, int* amountTo,
|
|
std::vector<int> categories, int types, std::vector<int> accounts, bool wildcards, std::vector<int> tags)
|
|
{
|
|
QSqlRecord set;
|
|
QSqlQuery query(_db);
|
|
QString req, v;
|
|
bool firstCond = false;
|
|
std::vector<int>::iterator it;
|
|
std::vector<Account>::iterator accountIt;
|
|
std::vector<Operation>* res = new std::vector<Operation>;
|
|
int i;
|
|
|
|
QString dayFrom, monthFrom, yearFrom;
|
|
QString dayTo, monthTo, yearTo;
|
|
QString desc;
|
|
|
|
if (dateFrom)
|
|
{
|
|
dayFrom = QString::number(dateFrom->day()-1);
|
|
monthFrom = QString::number(dateFrom->month()-1);
|
|
yearFrom = QString::number(dateFrom->year());
|
|
}
|
|
|
|
if (dateTo)
|
|
{
|
|
dayTo = QString::number(dateTo->day()-1);
|
|
monthTo = QString::number(dateTo->month()-1);
|
|
yearTo = QString::number(dateTo->year());
|
|
}
|
|
|
|
req = "SELECT * from operation WHERE ";
|
|
|
|
if (description)
|
|
{
|
|
desc = *description;
|
|
|
|
ESCAPE_CHARS(desc);
|
|
|
|
if (wildcards)
|
|
req += "UPPER(description) LIKE UPPER(\"%" + desc + "%\")";
|
|
else
|
|
req += "description=\"" + desc + "\"";
|
|
firstCond = true;
|
|
}
|
|
|
|
if (dateFrom)
|
|
{
|
|
if (firstCond) req += " AND " ; else firstCond = true;
|
|
req += "(";
|
|
req += "year >= " + yearFrom ;
|
|
req += " AND (month > '" + monthFrom + "' OR (month == '" + monthFrom + "' AND day >= '" + dayFrom + "')";
|
|
req += " OR (month < '" + monthFrom + "' AND year > '" + yearFrom + "'))";
|
|
req += ")";
|
|
}
|
|
|
|
if (dateTo)
|
|
{
|
|
if (firstCond) req += " AND " ; else firstCond = true;
|
|
req += "(";
|
|
req += "year <= " + yearTo ;
|
|
req += " AND (month < '" + monthTo + "' OR (month == '" + monthTo + "' AND day <= '" + dayTo + "')";
|
|
req += " OR (month > '" + monthTo + "' AND year < '" + yearTo + "'))";
|
|
req += ")";
|
|
}
|
|
|
|
if (amountFrom)
|
|
{
|
|
if (firstCond) req += " AND " ; else firstCond = true;
|
|
req += "ABS(amount) >= " + v.sprintf("%d", *amountFrom);
|
|
}
|
|
|
|
if (amountTo)
|
|
{
|
|
if (firstCond) req += " AND " ; else firstCond = true;
|
|
req += "ABS(amount) <= " + v.sprintf("%d", *amountTo);
|
|
}
|
|
|
|
if (categories.size())
|
|
{
|
|
if (firstCond) req += " AND " ; else firstCond = true;
|
|
req += "category IN ('";
|
|
it = categories.begin();
|
|
req += QString::number(*it);
|
|
it++;
|
|
|
|
for (; it != categories.end(); it++)
|
|
req += "', '" + QString::number(*it) ;
|
|
|
|
req += "')";
|
|
}
|
|
|
|
if (tags.size())
|
|
{
|
|
if (firstCond) req += " AND " ; else firstCond = true;
|
|
req += "tag IN ('";
|
|
it = tags.begin();
|
|
req += QString::number(*it);
|
|
it++;
|
|
|
|
for (; it != tags.end(); it++)
|
|
req += "', '" + QString::number(*it) ;
|
|
|
|
req += "')";
|
|
}
|
|
|
|
if (types)
|
|
{
|
|
if (((types & Database::FIX_OP) && !(types & Database::NON_FIX_OP)) ||
|
|
(!(types & Database::FIX_OP) && (types & Database::NON_FIX_OP)))
|
|
{
|
|
if (firstCond) req += " AND " ; else firstCond = true;
|
|
|
|
if (types & Database::FIX_OP)
|
|
req += " fix_cost='1'";
|
|
else
|
|
req += " fix_cost='0'";
|
|
}
|
|
|
|
if (((types & Database::CHECKED_OP) && !(types & Database::NOT_CHECKED_OP)) ||
|
|
(!(types & Database::CHECKED_OP) && (types & Database::NOT_CHECKED_OP)))
|
|
{
|
|
if (firstCond) req += " AND " ; else firstCond = true;
|
|
|
|
if (types & Database::CHECKED_OP)
|
|
req += " checked='1'";
|
|
else
|
|
req += " checked='0'";
|
|
}
|
|
}
|
|
|
|
if (firstCond) req += " AND " ; else firstCond = true;
|
|
|
|
if (accounts.size())
|
|
{
|
|
req += "(account IN ('";
|
|
it = accounts.begin();
|
|
req += QString::number(*it);
|
|
it++;
|
|
|
|
for (; it != accounts.end(); it++)
|
|
req += "', '" + QString::number(*it) ;
|
|
|
|
req += "'))";
|
|
// req += wxT(" OR user ='") + user->_id + "')";
|
|
}
|
|
else
|
|
{
|
|
req += "(account IN ('";
|
|
accountIt = user->_accounts.begin();
|
|
req += QString::number(accountIt->id);
|
|
accountIt++;
|
|
for (;accountIt != user->_accounts.end(); accountIt++)
|
|
{
|
|
req += "', '" + QString::number(accountIt->id) ;
|
|
}
|
|
req += "')";
|
|
req += " OR user ='" + QString::number(user->_id) + "')";
|
|
}
|
|
|
|
req += " ORDER BY year " ;
|
|
req += user->_preferences["operation_order"] ;
|
|
req += ", month " + user->_preferences["operation_order"] ;
|
|
req += ", day " + user->_preferences["operation_order"] ;
|
|
|
|
// std::cout << req.toStdString() << "\n";
|
|
|
|
EXECUTE_SQL_QUERY(req, res);
|
|
|
|
while (query.next())
|
|
{
|
|
Operation op;
|
|
set = query.record();
|
|
fillOperation(&op, set);
|
|
res->push_back(op);
|
|
}
|
|
|
|
for(i=0; i < (int)res->size(); i++)
|
|
if ((*res)[i].parent)
|
|
user->Group(res, (*res)[i]);
|
|
|
|
return res;
|
|
}
|
|
|
|
void Database::GetStats(User* user, int monthFrom, int yearFrom, int monthTo,
|
|
int yearTo, std::map<int, std::map<int, std::map<int, int> > >* accountAmounts,
|
|
std::map<int, int>* categories, std::map<int, int>* tags)
|
|
{
|
|
QSqlRecord set;
|
|
QSqlQuery query(_db);
|
|
QString req, req2;
|
|
std::vector<Account>::iterator accountIt;
|
|
std::vector<Category>::iterator categoryIt;
|
|
std::vector<Tag>::iterator tagIt;
|
|
|
|
if (!user->_accounts.empty())
|
|
{
|
|
if (accountAmounts)
|
|
{
|
|
for (accountIt = user->_accounts.begin(); accountIt != user->_accounts.end(); accountIt++)
|
|
{
|
|
req = "SELECT month, year, amount FROM account_amount WHERE account ='" + QString::number(accountIt->id) + "'";
|
|
req += " AND (year > '" + QString::number(yearFrom) + "' OR (year == '" + QString::number(yearFrom) + "' AND month >= '" + QString::number(monthFrom) + "'))";
|
|
req += " AND (year < '" + QString::number(yearTo) + "' OR (year == '" + QString::number(yearTo) + "' AND month <= '" + QString::number(monthTo) + "'))";
|
|
|
|
EXECUTE_SQL_QUERY(req, );
|
|
|
|
while (query.next())
|
|
{
|
|
set = query.record();
|
|
(*accountAmounts)[accountIt->id][set.value("year").toInt()][set.value("month").toInt()] = set.value("amount").toInt();
|
|
}
|
|
query.clear();
|
|
}
|
|
}
|
|
|
|
if (categories)
|
|
{
|
|
for (categoryIt = user->_categories.begin(); categoryIt != user->_categories.end(); categoryIt++)
|
|
{
|
|
if (categoryIt->id == 1)
|
|
req = "SELECT SUM(amount) as amount FROM operation AS o1 WHERE (category='" + QString::number(categoryIt->id) + "' OR fix_cost='1')";
|
|
else
|
|
req = "SELECT SUM(amount) as amount FROM operation AS o1 WHERE category='" + QString::number(categoryIt->id) + "'";
|
|
accountIt = user->_accounts.begin();
|
|
req += " AND (account IN('" + QString::number(accountIt->id);
|
|
accountIt++;
|
|
for (;accountIt != user->_accounts.end(); accountIt++)
|
|
{
|
|
req += "', '" + QString::number(accountIt->id) ;
|
|
}
|
|
req += "')";
|
|
req += " OR user='" + QString::number(user->_id) + "')";
|
|
|
|
req += " AND (year > '" + QString::number(yearFrom) + "' OR (year == '" + QString::number(yearFrom) + "' AND month >= '" + QString::number(monthFrom) + "'))";
|
|
req += " AND (year < '" + QString::number(yearTo) + "' OR (year == '" + QString::number(yearTo) + "' AND month <= '" + QString::number(monthTo) + "'))";
|
|
req += " AND meta='0'";
|
|
|
|
req2 = req + " AND (transfert='' OR transfert IS 0)";
|
|
req2 += " AND amount < 0";
|
|
|
|
EXECUTE_SQL_QUERY(req2, );
|
|
|
|
if (query.next())
|
|
{
|
|
set = query.record();
|
|
(*categories)[categoryIt->id] = -set.value("amount").toInt();
|
|
}
|
|
query.clear();
|
|
|
|
// Transfert on blocked accounts must be computed
|
|
req2 = req + " AND transfert != ''";
|
|
req2 += " AND (SELECT blocked FROM account WHERE id=o1.account)";
|
|
req2 += " AND amount > 0";
|
|
|
|
EXECUTE_SQL_QUERY(req2, );
|
|
|
|
if (query.next())
|
|
{
|
|
set = query.record();
|
|
(*categories)[categoryIt->id] += set.value("amount").toInt();
|
|
}
|
|
query.clear();
|
|
}
|
|
}
|
|
|
|
if (tags)
|
|
{
|
|
for (tagIt = user->_tags.begin(); tagIt != user->_tags.end(); tagIt++)
|
|
{
|
|
req = "SELECT SUM(amount) as amount FROM operation AS o1 WHERE tag='" + QString::number(tagIt->id) + "'";
|
|
accountIt = user->_accounts.begin();
|
|
req += " AND (account IN('" + QString::number(accountIt->id);
|
|
accountIt++;
|
|
for (;accountIt != user->_accounts.end(); accountIt++)
|
|
{
|
|
req += "', '" + QString::number(accountIt->id) ;
|
|
}
|
|
req += "')";
|
|
req += " OR user='" + QString::number(user->_id) + "')";
|
|
|
|
req += " AND (year > '" + QString::number(yearFrom) + "' OR (year == '" + QString::number(yearFrom) + "' AND month >= '" + QString::number(monthFrom) + "'))";
|
|
req += " AND (year < '" + QString::number(yearTo) + "' OR (year == '" + QString::number(yearTo) + "' AND month <= '" + QString::number(monthTo) + "'))";
|
|
req += " AND meta='0'";
|
|
|
|
req2 = req + " AND (transfert='' OR transfert IS 0)";
|
|
req2 += " AND amount < 0";
|
|
|
|
EXECUTE_SQL_QUERY(req2, );
|
|
|
|
if (query.next())
|
|
{
|
|
set = query.record();
|
|
(*tags)[tagIt->id] = -set.value("amount").toInt();
|
|
}
|
|
query.clear();
|
|
|
|
// Transfert on blocked accounts must be computed
|
|
req2 = req + " AND transfert != ''";
|
|
req2 += " AND (SELECT blocked FROM account WHERE id=o1.account)";
|
|
req2 += " AND amount > 0";
|
|
|
|
EXECUTE_SQL_QUERY(req2, );
|
|
|
|
if (query.next())
|
|
{
|
|
set = query.record();
|
|
(*tags)[tagIt->id] += set.value("amount").toInt();
|
|
}
|
|
query.clear();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Database::GetMonthStats(User* user, int month, int year, int nbDays,
|
|
std::map<int, std::vector<int> >* operations,
|
|
std::map<int, int>* categories, std::map<int, int>* tags)
|
|
{
|
|
QSqlRecord set;
|
|
QSqlQuery query(_db);
|
|
QString req;
|
|
std::vector<Account>::iterator accountIt;
|
|
int previous_amount, previous_day, cur_day;
|
|
|
|
if (!user->_accounts.empty())
|
|
{
|
|
for (accountIt = user->_accounts.begin(); accountIt != user->_accounts.end(); accountIt++)
|
|
{
|
|
req = "SELECT amount FROM account_amount WHERE account ='%1' AND year='%2' AND month='%3'";
|
|
req = req.arg(QString::number(accountIt->id), QString::number(year), QString::number(month));
|
|
|
|
EXECUTE_SQL_QUERY(req, );
|
|
|
|
while (query.next())
|
|
{
|
|
set = query.record();
|
|
(*operations)[accountIt->id].clear();
|
|
|
|
previous_amount = set.value("amount").toInt();
|
|
}
|
|
query.clear();
|
|
|
|
req = "SELECT day, amount FROM operation WHERE account='%1' AND year='%2' AND month='%3' AND meta='0' ORDER BY day ASC";
|
|
req = req.arg(QString::number(accountIt->id), QString::number(year), QString::number(month));
|
|
|
|
EXECUTE_SQL_QUERY(req, );
|
|
|
|
cur_day = previous_day = -1;
|
|
while (query.next())
|
|
{
|
|
set = query.record();
|
|
|
|
cur_day = set.value("day").toInt();
|
|
while (cur_day != previous_day)
|
|
{
|
|
(*operations)[accountIt->id].push_back(previous_amount);
|
|
previous_day++;
|
|
}
|
|
|
|
previous_amount += set.value("amount").toInt();
|
|
(*operations)[accountIt->id][cur_day] = previous_amount;
|
|
}
|
|
query.clear();
|
|
|
|
while (cur_day < nbDays)
|
|
{
|
|
(*operations)[accountIt->id].push_back(previous_amount);
|
|
cur_day++;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fill categories
|
|
GetStats(user, month, year, month, year, 0, categories, tags) ;
|
|
}
|
|
|
|
std::map<int, int>* Database::GetNotChecked(User* user, int month, int year)
|
|
{
|
|
std::vector<Account>::iterator accountIt;
|
|
std::map<int, int>* res = new std::map<int, int>;
|
|
QSqlRecord set;
|
|
QSqlQuery query(_db);
|
|
QString req;
|
|
|
|
for (accountIt = user->_accounts.begin() ;accountIt != user->_accounts.end(); accountIt++)
|
|
{
|
|
req = "SELECT SUM(amount) AS amount FROM operation WHERE account='" + QString::number(accountIt->id) + "'";
|
|
req += " AND checked='0'";
|
|
req += " AND meta='0'";
|
|
req += " AND virtual='0'";
|
|
req += " AND (year < '" + QString::number(year) + "'" ;
|
|
req += " OR (year == '" + QString::number(year) + "'" ;
|
|
req += " AND month < '" + QString::number(month) + "'" ;
|
|
req += "))";
|
|
|
|
EXECUTE_SQL_QUERY_WITH_CODE(req, 0, delete res, delete res);
|
|
|
|
if (query.next())
|
|
{
|
|
set = query.record();
|
|
(*res)[accountIt->id] = set.value("amount").toInt();
|
|
}
|
|
|
|
query.clear();
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
std::map<int, int>* Database::GetVirtualAmount(User* user, int month, int year)
|
|
{
|
|
std::vector<Account>::iterator accountIt;
|
|
std::map<int, int>* res = new std::map<int, int>;
|
|
QSqlRecord set;
|
|
QSqlQuery query(_db);
|
|
QString req;
|
|
|
|
for (accountIt = user->_accounts.begin() ;accountIt != user->_accounts.end(); accountIt++)
|
|
{
|
|
req = "SELECT SUM(amount) AS amount FROM operation WHERE account='" + QString::number(accountIt->id) + "'";
|
|
req += " AND virtual='1'";
|
|
req += " AND meta='0'";
|
|
req += " AND (year < '" + QString::number(year) + "'" ;
|
|
req += " OR (year == '" + QString::number(year) + "'" ;
|
|
req += " AND month < '" + QString::number(month) + "'" ;
|
|
req += "))";
|
|
|
|
EXECUTE_SQL_QUERY_WITH_CODE(req, 0, delete res, delete res);
|
|
|
|
if (query.next())
|
|
{
|
|
set = query.record();
|
|
(*res)[accountIt->id] = set.value("amount").toInt();
|
|
}
|
|
|
|
query.clear();
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
std::map<QString, QString> Database::getSharedAccountOwners(int account)
|
|
{
|
|
std::map<QString, QString> res;
|
|
QSqlRecord set, set2;
|
|
QSqlQuery query(_db);
|
|
QString req, user;
|
|
|
|
req = QString("SELECT user FROM shared_account WHERE account='%1'").arg(account);
|
|
|
|
EXECUTE_SQL_QUERY(req, res);
|
|
|
|
while(query.next())
|
|
{
|
|
set = query.record();
|
|
|
|
user = set.value("user").toString();
|
|
|
|
req = QString("SELECT name FROM user WHERE id='%1'").arg(set.value("user").toString());
|
|
|
|
query.clear();
|
|
|
|
EXECUTE_SQL_QUERY(req, res);
|
|
|
|
if (query.next())
|
|
{
|
|
set2 = query.record();
|
|
|
|
res[set2.value("name").toString()] = user;
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
QString Database::getSharedAccountOwner(int account)
|
|
{
|
|
QSqlRecord set ;
|
|
QSqlQuery query(_db);
|
|
QString req;
|
|
|
|
req = QString("SELECT user FROM account WHERE id='%1'").arg(account);
|
|
|
|
EXECUTE_SQL_QUERY(req, "");
|
|
|
|
if (query.next())
|
|
{
|
|
set = query.record();
|
|
|
|
req = QString("SELECT name FROM user WHERE id='%1'").arg(set.value("user").toString());
|
|
|
|
query.clear();
|
|
|
|
EXECUTE_SQL_QUERY(req, "");
|
|
|
|
if (query.next())
|
|
{
|
|
set = query.record();
|
|
|
|
return set.value("name").toString();
|
|
}
|
|
}
|
|
|
|
return "";
|
|
}
|
|
|
|
void Database::UpdateImportPattern(User* user)
|
|
{
|
|
std::map<QString, ImportPattern>::iterator it;
|
|
QString req, key;
|
|
QSqlQuery query(_db);
|
|
|
|
for (it = user->_importPatterns.begin();
|
|
it != user->_importPatterns.end();
|
|
it++)
|
|
{
|
|
if (it->second.pattern == ImportEngine::NULL_IMPORT_PATTERN) continue;
|
|
|
|
key = ImportEngine::RemoveUnused(it->first);
|
|
|
|
req = "INSERT or REPLACE INTO import_pattern ('user', 'description', 'pattern', 'account', 'category') VALUES " ;
|
|
req += "('%1', '%2', '%3', '%4', '%5')";
|
|
req = req.arg(QString::number(user->_id), key, it->second.pattern, QString::number(it->second.account), QString::number(it->second.category));
|
|
EXECUTE_SQL_UPDATE(req, );
|
|
}
|
|
}
|
|
|
|
void Database::GetHistory(int month, int year, QStringList& list)
|
|
{
|
|
QSqlRecord set ;
|
|
QSqlQuery query(_db);
|
|
QString req;
|
|
|
|
req = QString("SELECT DISTINCT description AS d FROM operation");
|
|
req += " WHERE (year > '" + QString::number(year) + "' OR (year == '" + QString::number(year) + "' AND month >= '" + QString::number(month) + "'))";
|
|
req += " ORDER by description";
|
|
|
|
EXECUTE_SQL_QUERY(req, );
|
|
|
|
while (query.next())
|
|
{
|
|
set = query.record();
|
|
|
|
list << set.value("d").toString();
|
|
}
|
|
}
|
|
|
|
bool Database::ChangeDatabase(QString filename)
|
|
{
|
|
QString oldFilename = _db.databaseName();
|
|
|
|
_db.close();
|
|
|
|
_db.setDatabaseName(filename);
|
|
|
|
if (!_db.open())
|
|
{
|
|
QMessageBox::critical(0, _("Error"), _("Unable to open database"));
|
|
_db.setDatabaseName(oldFilename);
|
|
_db.open();
|
|
return false;
|
|
}
|
|
|
|
try {
|
|
CheckDatabaseVersion();
|
|
}
|
|
catch(...)
|
|
{
|
|
_db.setDatabaseName(oldFilename);
|
|
_db.open();
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|