KissCount/src/controller/KissCount.cpp

/*
Copyright 2010 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 "KissCount.h"
 
KissCount::KissCount(const char* bdd_filename) : _user(NULL)
{
  _wxUI = new wxUI(this, wxT("KissCount"), wxPoint(50, 50), wxSize(1024, 768));

  _wxUI->SetLanguage(wxLocale::GetSystemLanguage());

  _wxUI->Show(true);
  _wxUI->Centre();
  _wxUI->Disable();

  try
    {
      _db = new Database(bdd_filename);
    }
  catch (std::string s)
    {
      _wxUI->Close(true);
      throw s;
    }

  _wxUI->ChangeUser();
  _wxUI->Enable();
}

KissCount::~KissCount()
{
  delete _db;
  delete _wxUI;
  if (_user) delete _user;
}

std::list<wxString> KissCount::GetUsers()
{
  return _db->GetUsers();
}

bool KissCount::IsValidUser(const wxString& user, const wxString& password)
{
  return _db->IsValidUser(user, password) ;
}

void KissCount::LoadUser(const wxString& user)
{
  if (_user) delete _user;
  _user = _db->LoadUser(user) ;
  if (_user)
    _wxUI->LoadUser();
}

void KissCount::LoadYear(int year, bool force)
{
  if (!force && _user->_operations[year] != NULL) return;

  if (_user->_operations[year] != NULL)
    {
      delete _user->_operations[year];
      _user->_operations[year] = NULL;
    }
  
  _db->LoadYear(_user, year);
}

User* KissCount::GetUser()
{
  return _user;
}

double KissCount::GetAccountAmount(const wxString& id, int month, int year)
{
  return _db->GetAccountAmount(id, month, year);
}

void KissCount::UpdateOperation(Operation& op)
{
  // Unlink
  op.transfert = wxT("");
  _user->LinkOrUnlinkOperation(op);

  _db->UpdateOperation(op);

  // Link
  _user->LinkOrUnlinkOperation(op);
}

wxString KissCount::AddOperation(Operation& op)
{
  wxString ret = _db->AddOperation(_user, op);

  if (op.transfert.Length())
    _user->LinkOrUnlinkOperation(op);

  return ret;
}

void KissCount::DeleteOperation(Operation& op)
{
  if (op.transfert.Length())
    {
      op.transfert = wxT("");
      _user->LinkOrUnlinkOperation(op);
    }
  _db->DeleteOperation(op);
}

void KissCount::DeleteOperations(int month, int year)
{
  _db->DeleteOperations(_user, month, year);
  if (month != -1)
    (*_user->_operations[year]).erase(month);

  if (month == -1 || !_user->_operations[year]->size())
    {
      delete _user->_operations[year];
      _user->_operations.erase(year);
    }
}

void KissCount::SetAccountAmount(int month, int year, const wxString& accountId, double amount)
{
  _db->SetAccountAmount(month, year, accountId, amount);
}

wxString KissCount::AddAccount(Account& ac)
{
  ac.id = _db->AddAccount(_user, ac);
  _user->_accounts.push_back(ac);

  return ac.id;
}

void KissCount::UpdateAccount(Account& ac)
{
  std::vector<Account>::iterator it;
  int i;

  _db->UpdateAccount(ac);
  for (i=0, it=_user->_accounts.begin(); it !=_user->_accounts.end(); it++, i++)
    if (it->id == ac.id)
      _user->_accounts[i] = ac;
}

void KissCount::DeleteAccount(Account& ac)
{
  std::vector<Account>::iterator it;
  int i;

  _db->DeleteAccount(ac);
  for (i=0, it=_user->_accounts.begin(); it !=_user->_accounts.end(); it++, i++)
    if (it->id == ac.id)
      {
	_user->_accounts.erase(_user->_accounts.begin()+i);
	break;
      }
}

wxString KissCount::AddCategory(Category& category)
{
  wxString id;
  id = _db->AddCategory(_user, category);
  category.id = id;

  _user->_categories.push_back(category);

  return id;
}

void KissCount::UpdateCategory(Category& category)
{
  _db->UpdateCategory(category);
  
  for (int i=0; i<_user->GetCategoriesNumber();i++)
    if (_user->_categories[i].id == category.id)
      {
	_user->_categories[i] = category;
	break;
      }
}

void KissCount::DeleteCategory(Category& category)
{
  _db->DeleteCategory(_user, category);

  for (int i=0; i<_user->GetCategoriesNumber();i++)
    if (_user->_categories[i].id == category.id)
      {
	_user->_categories.erase(_user->_categories.begin()+i);
	break;
      }
}

std::map<int, std::vector<int> > KissCount::GetAllOperations()
{
  return _db->GetAllOperations(_user);
}

void KissCount::GenerateMonth(int monthFrom, int yearFrom, int monthTo, int yearTo)
{
  std::vector<Operation>::iterator it;
  Operation op;

  _db->GenerateMonth(_user, monthFrom, yearFrom, monthTo, yearTo);

  if (!_user->_operations[yearTo])
    _user->_operations[yearTo] = new std::map<unsigned int, std::vector<Operation> >();

  if (monthFrom != -1 && yearFrom != -1)
    {
      LoadYear(yearFrom, false);
      	
      for(it = (*_user->_operations[yearFrom])[monthFrom].begin();
	  it != (*_user->_operations[yearFrom])[monthFrom].end()
	    && it->fix_cost;
	  it++)
	{
	  op = *it;
	  op.month = monthTo;
	  op.year = yearTo;
	  op.id = AddOperation(op);
	  (*_user->_operations[yearTo])[monthTo].push_back(op);
	}
    }
  _wxUI->GenerateMonth(monthTo, yearTo);
}

void KissCount::ChangePassword(const wxString& password)
{
  _db->ChangePassword(_user, password);
}

bool KissCount::UserExists(const wxString& name)
{
  return _db->UserExists(name);
}

void KissCount::ChangeName(const wxString& name)
{
  _db->ChangeName(_user, name);
  _user->_name = name;
}

void KissCount::NewUser(const wxString& name)
{
  wxDateTime curDate;
  Account ac = {wxT(""), wxT("Account 1"), wxT(""), false, true};
  Category cat ;

  _db->NewUser(name);
  if (_user) delete _user;
  _user = _db->LoadUser(name) ;
  
  curDate.SetToCurrent();
  
  AddAccount(ac);

  cat.parent = wxT("0") ; cat.name = _("Fix") ; cat.color = OWN_YELLOW ;
  AddCategory(cat);
  cat.parent = wxT("0") ; cat.name = _("Groceries") ; cat.color = OWN_GREEN; 
  AddCategory(cat);
  cat.parent = wxT("0") ; cat.name = _("Hobbies") ; cat.color = OWN_GREEN; 
  AddCategory(cat);
  cat.parent = wxT("0") ; cat.name = _("Operating exepense") ; cat.color = OWN_GREEN; 
  AddCategory(cat);
  cat.parent = wxT("0") ; cat.name = _("Unexpected") ; cat.color = OWN_GREEN; 
  AddCategory(cat);
  cat.parent = wxT("0") ; cat.name = _("Other") ; cat.color = OWN_GREEN;
  AddCategory(cat);

  _db->GenerateMonth(_user, -1, -1, (int)curDate.GetMonth(), curDate.GetYear());
}

void KissCount::KillMe()
{
  _wxUI->KillMe();
  _db->KillMe(_user);
  delete _user;
  _user = NULL;
  _wxUI->ChangeUser();
}

void KissCount::SetLanguage(wxLanguage language)
{
  _user->_preferences[wxT("language")] = wxString::Format(wxT("%d"), language) ;
  _db->UpdatePreference(_user, wxT("language"));
}

/*
  ASC (default) or DESC
 */
void KissCount::SetOperationOrder(const wxString& order)
{
  _user->_preferences[wxT("operation_order")] = order;
  _db->UpdatePreference(_user, wxT("operation_order"));
}

std::vector<Operation>* KissCount::Search(wxString* description, wxDateTime* dateFrom, wxDateTime* dateTo,
					  wxString* amountFrom, wxString* amountTo,
					  std::vector<wxString> categories, std::vector<wxString> accounts)
{

  return _db->Search(_user, description, dateFrom, dateTo, amountFrom, amountTo, categories, accounts);
}

bool KissCount::SearchPreviousOperation(Operation* res, wxString& description, int month, int year)
{
  std::vector<Operation>* operations;
  wxDateTime* date ;
  //wxDateSpan threeMonths(0, 3); Not working :(
  std::vector<wxString> v;

  month -= 3;
  if (month < 0)
    {
      year -= 1;
      month += 12; 
    }

  date = new wxDateTime(0, (wxDateTime::Month)month, year);

  operations = Search(&description, date, NULL, NULL, NULL, v, v);

  delete date;

  if (!operations->size()) 
    {
      delete operations;
      return false;
    }

  *res = (*operations)[operations->size()-1];

  delete operations;

  return true;
}

void KissCount::GetStats(int monthFrom, int yearFrom, int monthTo, int yearTo, 
		std::map<wxString, std::map<int, std::map<int, double> > >* accountAmounts, 
		std::map<wxString, double>* categories)
{
  wxString monthF = wxString::Format(wxT("%d"), monthFrom);
  wxString monthT = wxString::Format(wxT("%d"), monthTo);
  wxString yearF = wxString::Format(wxT("%d"), yearFrom);
  wxString yearT = wxString::Format(wxT("%d"), yearTo);

  _db->GetStats(_user, monthF, yearF, monthT, yearT, accountAmounts, categories);
}

std::map<wxString, double>* KissCount::GetNotChecked(int month, int year)
{
  return _db->GetNotChecked(_user, month, year);
}