예제 #1
0
def get_account_by_guid(acct, guid):
    for a in acct.get_descendants():
        if not isinstance(a, Account):
            # Older versions of GnuCash just used a pointer to an Account here.
            a = Account(instance=a)
        if a.GetGUID().to_string() == guid:
            return a
    return None
예제 #2
0
def get_accounts(root, list=None):
    if list is None:
        list = []
    for child in root.get_children():
        account = Account(instance=child)
        if not account.get_children():
            list.append(account)
        get_accounts(account, list)
    return list
예제 #3
0
def find_account(account, name, account_list=None):
    """Recursively searches full names of account and descendents

  returns a list of accounts which contain name.
  
  options:
  
  account:      account to start search in.
  name:         name to search for.
  account_list: (optional) list to append accounts to.
  
  """

    if not account_list:
        account_list = []

    for child in account.get_children():
        if type(child) != Account:
            child = Account(instance=child)
        account_list = find_account(child, name, account_list)

    account_name = account.GetName()
    if name in account_name:
        account_list.append(account)

    return account_list
예제 #4
0
def _recursiveCopyAccounts(session, session_new, account, account_new,
                           commodtable):
    attributes = [
        'Hidden', 'ReconcileChildrenStatus', 'TaxUSCode', 'Code', 'LastNum',
        'TaxUSCopyNumber', 'Color', 'TaxUSPayerNameSource', 'Name', 'Type',
        'NonStdSCU', 'Description', 'Notes', 'SortOrder', 'Filter',
        'Placeholder', 'TaxRelated'
    ]

    for acc in account.get_children():
        acc_new = Account(session_new.book)
        account_new.append_child(acc_new)
        _recursiveCopyAccounts(session, session_new, acc, acc_new, commodtable)

    for attrib in attributes:
        getattr(account_new, 'Set' + attrib)(getattr(account,
                                                     'Get' + attrib)())

    # copy commodity
    orig_commodity = account.GetCommodity()
    if orig_commodity:
        namespace = orig_commodity.get_namespace()
        mnemonic = orig_commodity.get_mnemonic()
        new_commodity = commodtable.lookup(namespace, mnemonic)
        account_new.SetCommodity(new_commodity)
예제 #5
0
    def test_assignlots(self):
        abc = GncCommodity(self.book, 'ABC Fund',
            'COMMODITY','ABC','ABC',100000)
        self.table.insert(abc)
        self.account.SetCommodity(abc)

        other = Account(self.book)
        other.SetCommodity(self.currency)

        tx = Transaction(self.book)
        tx.BeginEdit()
        tx.SetCurrency(self.currency)
        tx.SetDateEnteredSecs(datetime.now())
        tx.SetDatePostedSecs(datetime.now())

        s1a = Split(self.book)
        s1a.SetParent(tx)
        s1a.SetAccount(self.account)
        s1a.SetAmount(GncNumeric(1.3))
        s1a.SetValue(GncNumeric(100.0))

        s1b = Split(self.book)
        s1b.SetParent(tx)
        s1b.SetAccount(other)
        s1b.SetAmount(GncNumeric(-100.0))
        s1b.SetValue(GncNumeric(-100.0))

        s2a = Split(self.book)
        s2a.SetParent(tx)
        s2a.SetAccount(self.account)
        s2a.SetAmount(GncNumeric(-1.3))
        s2a.SetValue(GncNumeric(-100.0))

        s2b = Split(self.book)
        s2b.SetParent(tx)
        s2b.SetAccount(other)
        s2b.SetAmount(GncNumeric(100.0))
        s2b.SetValue(GncNumeric(100.0))

        tx.CommitEdit()

        self.account.ScrubLots()
        self.assertEqual(len(self.account.GetLotList()),1)
def recursivly_build_account_tree(original_parent_account, new_parent_account,
                                  new_book, new_commodity_table,
                                  opening_balance_per_currency,
                                  account_types_to_open):

    for child in original_parent_account.get_children():
        original_account = child
        new_account = Account(new_book)
        # attach new account to its parent
        new_parent_account.append_child(new_account)

        # copy simple attributes
        for attribute in ('Name', 'Type', 'Description', 'Notes', 'Code',
                          'TaxRelated', 'Placeholder'):
            # new_account.SetAttribute( original_account.GetAttribute() )
            getattr(new_account,
                    'Set' + attribute)(getattr(original_account,
                                               'Get' + attribute)())

        # copy commodity
        orig_commodity = original_account.GetCommodity()
        namespace = orig_commodity.get_namespace()
        mnemonic = orig_commodity.get_mnemonic()
        new_commodity = new_commodity_table.lookup(namespace, mnemonic)
        if new_commodity == None:
            new_commodity = orig_commodity.clone(new_book)
            new_commodity_table.insert(new_commodity)
        new_account.SetCommodity(new_commodity)

        record_opening_balance(
            original_account,
            new_account,
            new_book,
            opening_balance_per_currency,
            (namespace, mnemonic),
        )

        recursivly_build_account_tree(original_account, new_account, new_book,
                                      new_commodity_table,
                                      opening_balance_per_currency,
                                      account_types_to_open)
def find_or_make_account(account_tuple, root_account, book, currency):
    current_account_name, account_path = account_tuple[0], account_tuple[1:]
    current_account = root_account.lookup_by_name(current_account_name)
    if current_account == None:
        current_account = Account(book)
        current_account.SetName(current_account_name)
        current_account.SetCommodity(currency)
        root_account.append_child(current_account)

    if len(account_path) > 0:
        return find_or_make_account(account_path, current_account, book,
                                    currency)
    else:
        account_commod = current_account.GetCommodity()
        if (account_commod.get_mnemonic(),
            account_commod.get_namespace() ) == \
            (currency.get_mnemonic(),
             currency.get_namespace()) :
            return current_account
        else:
            return None
예제 #8
0
    def setUp(self):
        BookSession.setUp(self)

        self.today = datetime.today()

        self.bank = Account(self.book)
        self.bank.SetType(ACCT_TYPE_BANK)
        self.bank.SetCommodity(self.currency)
        self.income = Account(self.book)
        self.income.SetType(ACCT_TYPE_INCOME)
        self.income.SetCommodity(self.currency)
        self.receivable = Account(self.book)
        self.receivable.SetType(ACCT_TYPE_RECEIVABLE)
        self.receivable.SetCommodity(self.currency)

        self.customer = Customer(self.book,'CustomerID',self.currency)
        self.vendor = Vendor(self.book,'VendorID',self.currency)
        self.employee = Employee(self.book,'EmployeeID',self.currency)
        self.job = Job(self.book,'JobID',self.customer)

        self.invoice = Invoice(self.book,'InvoiceID',self.currency,self.customer)
        self.invoice.SetDateOpened(self.today)
        entry = Entry(self.book)
        entry.SetDate(self.today)
        entry.SetDescription("Some income")
        entry.SetQuantity(GncNumeric(1))
        entry.SetInvAccount(self.income)
        entry.SetInvPrice(GncNumeric(100))
        self.invoice.AddEntry(entry)

        self.invoice.PostToAccount(self.receivable,
            self.today, self.today, "", True, False)
예제 #9
0
파일: tax.py 프로젝트: jfishe/qb2gnc
def new_tax(root, book, USD, row):
    if row['type'] == 'Sales Tax Item':
        tablename = row['item']
        parent = root.lookup_by_name(row['account'])
        account = Account(book)
        parent.append_child(account)
        account.SetName(tablename)
        account.SetType(ACCT_TYPE_LIABILITY)
        account.SetCommodity(USD)
        rate = gnc_numeric_from(row['rate'])
        # Skip existing tax table and create new ones
        try:
            assert (
                not isinstance(book.TaxTableLookupByName(tablename), TaxTable)
            )
            TaxTable(book, tablename, TaxTableEntry(account, True, rate))
        except AssertionError:
            print '"%s" tax table already exists, skipping' \
                  % tablename
            # Add method to update rate
            return 0
    return 1
예제 #10
0
def mark_account_with_code_as_tax_related(account, target_code):
    """Looks at account to see if it has the target_account_code, if so
    set the account tax related flag to True and return True.
    If not, recursively tries to do the same to all children accounts
    of account.
    Returns False when recursion fails to find it.
    """
    if account.GetCode() == target_code:
        account.SetTaxRelated(True)
        return True
    else:
        for child in account.get_children():
            child = Account(instance=child)
            if mark_account_with_code_as_tax_related(child, target_code):
                return True
        return False
예제 #11
0
def createAccounts(book):
    root_account = book.get_root_account()
    commodtable = book.get_table()
    currency = commodtable.lookup("CURRENCY", "EUR")
    ses.save()

    print('Create two accounts ("Account A", "Account B")')
    accountA = Account(book)
    accountA.SetCommodity(currency)
    accountA.SetName("Account A")
    root_account.append_child(accountA)

    accountB = Account(book)
    accountB.SetCommodity(currency)
    accountB.SetName("Account B")
    root_account.append_child(accountB)

    #ses.save()

    return accountA, accountB
예제 #12
0
    def get_accounts(self, ast_parent:Account, asset_acct_name:str, rev_acct:Account):
        """
        Find the proper Asset and Revenue accounts
        :param      ast_parent: Asset account parent
        :param asset_acct_name: Asset account name
        :param        rev_acct: Revenue account
        :return: Gnucash account, Gnucash account
        """
        self.logger.print_info('get_accounts()', BLUE)
        asset_parent = ast_parent
        # special locations for Trust Revenue and Asset accounts
        if asset_acct_name == TRUST_AST_ACCT:
            asset_parent = self.root_acct.lookup_by_name(TRUST)
            self.logger.print_info("asset_parent = {}".format(asset_parent.GetName()))
            rev_acct = self.root_acct.lookup_by_name(TRUST_REV_ACCT)
            self.logger.print_info("MODIFIED rev_acct = {}".format(rev_acct.GetName()))
        # get the asset account
        asset_acct = asset_parent.lookup_by_name(asset_acct_name)
        if asset_acct is None:
            raise Exception("[164] Could NOT find acct '{}' under parent '{}'"
                            .format(asset_acct_name, asset_parent.GetName()))

        self.logger.print_info("asset_acct = {}".format(asset_acct.GetName()), color=CYAN)
        return asset_acct, rev_acct
예제 #13
0
def find_split_recursive(account, search_string):
    """Searches account and descendants for Splits containing search_string
  
  returns a list of splits that have search_string as part of
  memo or
  description of parent transaction.
  
  options:
 
  account:        Account to search in.
  search_string:  String to search for.
  
  """

    rlist = []
    child_account_splits = []

    # Get all splits in descendants
    for child in account.get_children():
        if type(child) != Account:
            child = Account(instance=child)
        childsplits = find_split_recursive(child, search_string)
        for split in childsplits:
            if type(split) != Split:
                split = Split(instance=split)
        child_account_splits += childsplits

    # Get all splits in account
    splits = account.GetSplitList()
    for split in splits:
        if type(split) != Split:
            split = Split(instance=split)
    basic_account_splits = find_split(splits, search_string)

    rlist = child_account_splits + basic_account_splits
    return rlist
예제 #14
0
#!/usr/bin/env python3
##  @file
#   @brief Example Script simple sqlite create 
#   @ingroup python_bindings_examples

from gnucash import Session, Account
from os.path import abspath
from gnucash.gnucash_core_c import ACCT_TYPE_ASSET

s = Session('sqlite3://%s' % abspath('test.blob'), is_new=True)
# this seems to make a difference in more complex cases
s.save()

book = s.book
root = book.get_root_account()
a = Account(book)
root.append_child(a)
a.SetName('wow')
a.SetType(ACCT_TYPE_ASSET)

commod_table = book.get_table()
a.SetCommodity( commod_table.lookup('CURRENCY', 'CAD') )
s.save()

s.end()
예제 #15
0
#!/usr/bin/env python
# Creates a basic set of accounts and a couple of transactions

from gnucash import Session, Account, Transaction, Split, GncNumeric

FILE_1 = "/tmp/example.gnucash"

session = Session("xml:%s" % FILE_1, True)

book = session.book
root_acct = Account(book)
expenses_acct = Account(book)
savings_acct = Account(book)
opening_acct = Account(book)
trans1 = Transaction(book)
trans2 = Transaction(book)
split1 = Split(book)
split3 = Split(book)
comm_table = book.get_table()
cad = comm_table.lookup("CURRENCY", "CAD")

num1 = GncNumeric(4, 1)
num2 = GncNumeric(100, 1)

#Set new root account
book.set_root_account(root_acct)

#Set up root account and add sub-accounts
root_acct.SetName("Root")
root_acct.SetType(13) #ACCT_TYPE_ROOT = 13
root_acct.append_child(expenses_acct)
예제 #16
0
 def setUp(self):
     BookSession.setUp(self)
     self.account = Account(self.book)
예제 #17
0
    print "not enough parameters"
    print "usage: simple_business_create.py {new_book_url}"
    print "example:"
    print "gnucash-env python simple_business_create.py sqlite3:///home/blah/blah.gnucash"
    exit()


try:
    s = Session(argv[1], is_new=True)

    book = s.book
    root = book.get_root_account()
    commod_table = book.get_table()
    CAD = commod_table.lookup("CURRENCY", "CAD")

    a = Account(book)
    root.append_child(a)
    a.SetName("Assets")
    a.SetType(ACCT_TYPE_ASSET)
    a.SetCommodity(CAD)

    a2 = Account(book)
    a.append_child(a2)
    a2.SetName("Receivables")
    a2.SetType(ACCT_TYPE_RECEIVABLE)
    a2.SetCommodity(CAD)

    a3 = Account(book)
    root.append_child(a3)
    a3.SetName("Income")
    a3.SetType(ACCT_TYPE_INCOME)
예제 #18
0
 def test_account(self):
     ACCT = Account(self.book)
     ACCT.SetCommodity(self.currency)
     self.split.SetAccount(ACCT)
     self.assertTrue(ACCT.Equal(self.split.GetAccount(), True))
예제 #19
0
#!/usr/bin/env python
## @file
# @brief Creates a basic set of accounts and a couple of transactions
# @ingroup python_bindings_examples

from gnucash import Session, Account, Transaction, Split, GncNumeric

FILE_1 = "/tmp/example.gnucash"

session = Session("xml://%s" % FILE_1, is_new=True)

book = session.book
root_acct = Account(book)
expenses_acct = Account(book)
savings_acct = Account(book)
opening_acct = Account(book)
trans1 = Transaction(book)
trans1.BeginEdit()
trans2 = Transaction(book)
trans2.BeginEdit()

split1 = Split(book)
split3 = Split(book)
comm_table = book.get_table()
cad = comm_table.lookup("CURRENCY", "CAD")

num1 = GncNumeric(4, 1)
num2 = GncNumeric(100, 1)

#Set new root account
book.set_root_account(root_acct)
예제 #20
0
# for a file, simply pass the pathname, for a database you can use
# these forms:
# mysql://user:password@host/dbname
# postgres://user:password@host[:port]/dbname (the port is optional)
#
# You should try it out with a gnucash file with tranding accounts enabled
# and trading accounts disabled
session = Session(argv[1])
book = session.book

root = book.get_root_account()
root.get_instance()
commod_tab = session.book.get_table()
CAD = commod_tab.lookup("ISO4217", "CAD")
USD = commod_tab.lookup("ISO4217", "USD")
account = Account(book)
account2 = Account(book)
root.append_child(account)
root.append_child(account2)
account.SetCommodity(CAD)
account.SetName("blahblah")
account.SetType(3)
account2.SetCommodity(USD)
account2.SetName("blahblahsdfs ")
account2.SetType(3)

a = Transaction(book)
a.BeginEdit()

s = Split(book)
s.SetParent(a)
예제 #21
0
 def test_findsplit(self):
     ACCT = Account(self.book)
     ACCT.SetCommodity(self.currency)
     self.split.SetAccount( ACCT )
     SPLIT = self.trans.FindSplitByAccount( ACCT )
     self.assertTrue( SPLIT.Equal(self.split, True, False, False) )
예제 #22
0
    print('not enough parameters')
    print('usage: simple_business_create.py {new_book_url}')
    print('example:')
    print(
        "python3 simple_business_create.py sqlite3:///home/blah/blah.gnucash")
    exit()

try:
    s = Session(argv[1], SessionOpenMode.SESSION_NEW_STORE)

    book = s.book
    root = book.get_root_account()
    commod_table = book.get_table()
    CAD = commod_table.lookup('CURRENCY', 'CAD')

    a = Account(book)
    root.append_child(a)
    a.SetName('Assets')
    a.SetType(ACCT_TYPE_ASSET)
    a.SetCommodity(CAD)

    a2 = Account(book)
    a.append_child(a2)
    a2.SetName('Receivables')
    a2.SetType(ACCT_TYPE_RECEIVABLE)
    a2.SetCommodity(CAD)

    a3 = Account(book)
    root.append_child(a3)
    a3.SetName('Income')
    a3.SetType(ACCT_TYPE_INCOME)
예제 #23
0
 def test_account(self):
     ACCT = Account(self.book)
     self.split.SetAccount(ACCT)
     self.assertTrue( ACCT.Equal(self.split.GetAccount(), True) )