mymoneyfile.h

Go to the documentation of this file.

/***************************************************************************
                          mymoneyfile.h
                             -------------------
    copyright            : (C) 2002, 2007 by Thomas Baumgart
    email                : ipwizard@users.sourceforge.net
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program 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 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef MYMONEYFILE_H
#define MYMONEYFILE_H

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

// ----------------------------------------------------------------------------
// QT Includes

#include <qobject.h>
#include <qstring.h>
#include <qmap.h>
#include <qvaluelist.h>

// ----------------------------------------------------------------------------
// Project Includes

#include <kmymoney/imymoneystorage.h>
#include <kmymoney/mymoneyexception.h>
#include <kmymoney/mymoneyutils.h>
#include <kmymoney/mymoneyinstitution.h>
#include <kmymoney/mymoneyaccount.h>
#include <kmymoney/mymoneytransaction.h>
#include <kmymoney/mymoneypayee.h>
#include <kmymoney/mymoneykeyvaluecontainer.h>
#include <kmymoney/mymoneysecurity.h>
#include <kmymoney/mymoneyprice.h>
#include <kmymoney/mymoneyreport.h>
#include <kmymoney/mymoneybudget.h>
#include <kmymoney/mymoneyscheduled.h>
#include <kmymoney/export.h>

class IMyMoneyStorage;
class MyMoneyTransactionFilter;
class MyMoneyFilePrivate;

class KMYMONEY_EXPORT MyMoneyFile : public QObject
{
  Q_OBJECT
public:

  class MyMoneyNotifier
  {
  public:
    MyMoneyNotifier(MyMoneyFile* file) { m_file = file; m_file->clearNotification(); };
    ~MyMoneyNotifier() { m_file->notify(); };
  private:
    MyMoneyFile* m_file;
  };

  friend class MyMoneyNotifier;

  static inline MyMoneyFile* instance() { return &file; }

  ~MyMoneyFile();

  MyMoneyFile(IMyMoneyStorage *storage);

  // general get functions
  const MyMoneyPayee user(void) const;

  // general set functions
  void setUser(const MyMoneyPayee& user);

  void attachStorage(IMyMoneyStorage* const storage);

  void detachStorage(IMyMoneyStorage* const storage = 0);

  bool storageAttached(void) const { return m_storage != 0; };

  IMyMoneyStorage* storage(void) const { return m_storage; };

  void startTransaction(void);

  bool hasTransaction(void) const;

  void commitTransaction(void);

  void rollbackTransaction(void);

  const MyMoneyAccount& liability(void) const;

  const MyMoneyAccount& asset(void) const;

  const MyMoneyAccount& expense(void) const;

  const MyMoneyAccount& income(void) const;

  const MyMoneyAccount& equity(void) const;

  const MyMoneyAccount openingBalanceAccount(const MyMoneySecurity& security);

  const MyMoneyAccount openingBalanceAccount(const MyMoneySecurity& security) const;

  void createOpeningBalanceTransaction(const MyMoneyAccount& acc, const MyMoneyMoney& balance);

  const QCString openingBalanceTransaction(const MyMoneyAccount& acc) const;

  bool dirty(void) const;

  void setDirty(void) const;

  void addInstitution(MyMoneyInstitution& institution);

  void modifyInstitution(const MyMoneyInstitution& institution);

  void removeInstitution(const MyMoneyInstitution& institution);

  void addAccount(MyMoneyAccount& account, MyMoneyAccount& parent);

  void modifyAccount(const MyMoneyAccount& account);

  void reparentAccount(MyMoneyAccount &account, MyMoneyAccount& parent);

  unsigned int moveSplits(const QCString& oldAccount, const QCString& newAccount);

  bool hasActiveSplits(const QCString& id) const;

  bool isStandardAccount(const QCString& id) const;

  bool isTransfer(const MyMoneyTransaction& t) const;

  void setAccountName(const QCString& id, const QString& name) const;

  void removeAccount(const MyMoneyAccount& account);

  void removeAccountList(const QCStringList& account_list, unsigned int level = 0);

  bool hasOnlyUnusedAccounts(const QCStringList& account_list, unsigned int level = 0);

  void addTransaction(MyMoneyTransaction& transaction);

  void modifyTransaction(const MyMoneyTransaction& transaction);

  const MyMoneyTransaction transaction(const QCString& id) const;

  const MyMoneyTransaction transaction(const QCString& account, const int idx) const;

  const QValueList<MyMoneyTransaction> transactionList(MyMoneyTransactionFilter& filter) const;

  void transactionList(QValueList<MyMoneyTransaction>& list, MyMoneyTransactionFilter& filter) const;

  void transactionList(QValueList<QPair<MyMoneyTransaction, MyMoneySplit> >& list, MyMoneyTransactionFilter& filter) const;

  void removeTransaction(const MyMoneyTransaction& transaction);

  const MyMoneyMoney balance(const QCString& id, const QDate& date = QDate()) const;

  const MyMoneyMoney totalBalance(const QCString& id, const QDate& date = QDate()) const;

  unsigned int transactionCount(const QCString& account = QCString()) const;

  const QMap<QCString, unsigned long> transactionCountMap(void) const;

  unsigned int institutionCount(void) const;

  unsigned int accountCount(void) const;

  const MyMoneyInstitution& institution(const QCString& id) const;

  void institutionList(QValueList<MyMoneyInstitution>& list) const;

  const QValueList<MyMoneyInstitution> institutionList(void) const;

  const MyMoneyAccount& account(const QCString& id) const;

  const MyMoneyAccount& accountByName(const QString& name) const;

  const MyMoneyAccount& subAccountByName(const MyMoneyAccount& acc, const QString& name) const;

  void accountList(QValueList<MyMoneyAccount>& list, const QCStringList& idlist = QCStringList(), const bool recursive = false) const;

  const QString accountToCategory(const QCString& accountId, bool includeStandardAccounts = false) const;

  const QCString categoryToAccount(const QString& category, MyMoneyAccount::accountTypeE type = MyMoneyAccount::UnknownAccountType) const;

  const QCString nameToAccount(const QString& name) const;

  const QString parentName(const QString& name) const;

  void addPayee(MyMoneyPayee& payee);

  const MyMoneyPayee& payee(const QCString& id) const;

  const MyMoneyPayee& payeeByName(const QString& payee) const;

  void modifyPayee(const MyMoneyPayee& payee);

  void removePayee(const MyMoneyPayee& payee);

  const QValueList<MyMoneyPayee> payeeList(void) const;

  const QString value(const QCString& key) const;

  void setValue(const QCString& key, const QString& val);

  void deletePair(const QCString& key);

  void addSchedule(MyMoneySchedule& sched);

  void modifySchedule(const MyMoneySchedule& sched);

  void removeSchedule(const MyMoneySchedule& sched);

  const MyMoneySchedule schedule(const QCString& id) const;

  const QValueList<MyMoneySchedule> scheduleList(const QCString& accountId = QCString(),
                                     const MyMoneySchedule::typeE type = MyMoneySchedule::TYPE_ANY,
                                     const MyMoneySchedule::occurenceE occurence = MyMoneySchedule::OCCUR_ANY,
                                     const MyMoneySchedule::paymentTypeE paymentType = MyMoneySchedule::STYPE_ANY,
                                     const QDate& startDate = QDate(),
                                     const QDate& endDate = QDate(),
                                     const bool overdue = false) const;

  const QStringList consistencyCheck(void);

  static const QString OpeningBalancesPrefix;

  static const QString AccountSeperator;

  const QCString createCategory(const MyMoneyAccount& base, const QString& name);

  const QValueList<MyMoneySchedule> scheduleListEx( int scheduleTypes,
                                              int scheduleOcurrences,
                                              int schedulePaymentTypes,
                                              QDate startDate,
                                              const QCStringList& accounts=QCStringList()) const;

  void addSecurity(MyMoneySecurity& security);

  void modifySecurity(const MyMoneySecurity& security);

  void removeSecurity(const MyMoneySecurity& security);

  const MyMoneySecurity& security(const QCString& id) const;

  const QValueList<MyMoneySecurity> securityList(void) const;

  void addCurrency(const MyMoneySecurity& currency);

  void modifyCurrency(const MyMoneySecurity& currency);

  void removeCurrency(const MyMoneySecurity& currency);

  const MyMoneySecurity& currency(const QCString& id) const;

  const QValueList<MyMoneySecurity> currencyList(void) const;

  const MyMoneySecurity& baseCurrency(void) const;

  const QCString& foreignCurrency(const QCString& first, const QCString& second) const;

  void setBaseCurrency(const MyMoneySecurity& currency);

  void addPrice(const MyMoneyPrice& price);

  void removePrice(const MyMoneyPrice& price);

  const MyMoneyPrice price(const QCString& fromId, const QCString& toId = QCString(), const QDate& date = QDate::currentDate(), const bool exactDate = false) const;

  const MyMoneyPriceList priceList(void) const;

  bool hasAccount(const QCString& id, const QString& name) const;

  const QValueList<MyMoneyReport> reportList( void ) const;

  void addReport( MyMoneyReport& report );

  void modifyReport( const MyMoneyReport& report );

  unsigned countReports( void ) const;

  const MyMoneyReport report( const QCString& id ) const;

  void removeReport(const MyMoneyReport& report);

  const QValueList<MyMoneyBudget> budgetList( void ) const;

  void addBudget( MyMoneyBudget& budget );


  const MyMoneyBudget budgetByName(const QString& budget) const;


  void modifyBudget( const MyMoneyBudget& budget );

  unsigned countBudgets( void ) const;

  const MyMoneyBudget budget( const QCString& id ) const;

  void removeBudget(const MyMoneyBudget& budget);


  bool isReferenced(const MyMoneyObject& obj, const MyMoneyFileBitArray& skipCheck = MyMoneyFileBitArray()) const;

  bool checkNoUsed(const QCString& accId, const QString& no) const;

  const QString highestCheckNo(const QCString& accId) const;

  void clearCache(void);

  void forceDataChanged(void) { emit dataChanged(); }

  void preloadCache(void);

protected:
  MyMoneyFile();

signals:
  void dataChanged(void);

private:
  static MyMoneyFile file;

  MyMoneyFile& operator=(MyMoneyFile&); // not allowed for singleton
  MyMoneyFile(const MyMoneyFile&);      // not allowed for singleton

  const QCString locateSubAccount(const MyMoneyAccount& base, const QString& category) const;

  void ensureDefaultCurrency(MyMoneyAccount& acc) const;

  void warningMissingRate(const QCString& fromId, const QCString& toId) const;

  const MyMoneyAccount createOpeningBalanceAccount(const MyMoneySecurity& security);

  const MyMoneyAccount openingBalanceAccount_internal(const MyMoneySecurity& security) const;

private:
  void addNotification(const QCString& id, bool reload = true);

  void clearNotification(void);

  void notify(void);

  inline void checkStorage(void) const {
    if(m_storage == 0)
      throw new MYMONEYEXCEPTION("No storage object attached to MyMoneyFile");
  }

  void checkTransaction(const char* txt) const;

private:
  IMyMoneyStorage *m_storage;

  MyMoneyFilePrivate* const d;

  static MyMoneyFile* _instance;
};

class KMYMONEY_EXPORT MyMoneyFileTransaction
{
public:
  MyMoneyFileTransaction();
  ~MyMoneyFileTransaction();

  void commit(void);
  void rollback(void);
  void restart(void);

private:
  bool m_isNested;
  bool m_needRollback;
};

#endif

---