def test_add_transfer(self):
account1 = next(account for account in self.client.budget.be_accounts
if account.account_name == 'account1')
account2 = next(account for account in self.client.budget.be_accounts
if account.account_name == 'account2')
try:
payee_2 = next(payee for payee in self.client.budget.be_payees
if payee.entities_account_id == account2.id)
except StopIteration:
payee_2 = Payee(entities_account_id=account2.id)
self.client.budget.be_payees.append(payee_2)
try:
payee_1 = next(payee for payee in self.client.budget.be_payees
if payee.entities_account_id == account1.id)
except StopIteration:
payee_1 = Payee(entities_account_id=account1.id)
self.client.budget.be_payees.append(payee_1)
transaction1 = Transaction(amount=random.randint(-10, 10),
date=datetime.now(),
entities_account_id=account1.id,
entities_payee_id=payee_2.id)
transaction2 = Transaction(amount=-transaction1.amount,
date=datetime.now(),
entities_account_id=account2.id,
entities_payee_id=payee_1.id)
self.client.budget.be_transactions.append(transaction1)
self.client.budget.be_transactions.append(transaction2)
self.client.sync()
self.reload()
self.assertIn(transaction1, self.client.budget.be_transactions)
self.assertIn(transaction2, self.client.budget.be_transactions)
def get_payee(self, payee_name):
try:
return next(payee for payee in self.client.budget.be_payees
if payee.name == payee_name)
except StopIteration:
logging.info('Creating new payee "{}"'.format(payee_name))
payee = Payee()
payee.name = payee_name
self.client.budget.be_payees.append(payee)
self.delta += 1
return payee
def add_account(self, account, balance, balance_date):
payee = Payee(
entities_account_id=account.id,
enabled=True,
auto_fill_subcategory_enabled=True,
auto_fill_memo_enabled=False,
auto_fill_amount_enabled=False,
rename_on_import_enabled=False,
name="Transfer : %s" % account.account_name
)
immediateincomeid = next(
s.id for s in self.budget.be_subcategories if s.internal_name == 'Category/__ImmediateIncome__')
startingbalanceid = next(p.id for p in self.budget.be_payees if p.internal_name == 'StartingBalancePayee')
transaction = Transaction(
accepted=True,
amount=balance,
entities_subcategory_id=immediateincomeid,
cash_amount=0,
cleared='Cleared',
date=balance_date,
entities_account_id=account.id,
credit_amount=0,
entities_payee_id=startingbalanceid,
is_tombstone=False
)
self.budget.be_accounts.append(account)
self.budget.be_payees.append(payee)
self.budget.be_transactions.append(transaction)
def client():
obj = factory.create_client(budget_name='TestBudget',
connection=MockConnection(),
sync=False)
session = obj.session
budget_version = BudgetVersion(version_name='TestBudget')
master_category = MasterCategory(name='master')
subcategory = SubCategory(name='Immediate Income',
internal_name='Category/__ImmediateIncome__',
entities_master_category=master_category)
payee = Payee(name='Starting Balance Payee',
internal_name='StartingBalancePayee')
session.add(master_category)
session.add(subcategory)
session.add(payee)
obj.catalog.ce_budget_versions.append(budget_version)
obj.budget.be_master_categories.append(master_category)
obj.budget.be_subcategories.append(subcategory)
obj.budget.be_payees.append(payee)
session.commit()
obj.budgetClient.clear_changed_entities()
obj.catalogClient.clear_changed_entities()
obj.budgetClient.device_knowledge_of_server = 0
obj.catalogClient.device_knowledge_of_server = 0
obj.budgetClient.current_device_knowledge = 0
obj.catalogClient.current_device_knowledge = 0
return obj
def migrate_main():
print('migrate YNAB4 to pynYNAB')
"""Migrate a YNAB4 budget transaction history to nYNAB, using pyynab"""
parser = configargparse.getArgumentParser('pynYNAB')
parser.description = inspect.getdoc(migrate_main)
parser.add_argument('budget',
metavar='BudgetPath',
type=str,
help='The budget .ynab4 directory')
args = parser.parse_args()
test_common_args(args)
budget_base_name = os.path.basename(args.budget)
budget_path = os.path.dirname(args.budget)
budget_name = re.match(r"(?P<budget_name>.*)~[A-Z0-9]{8}\.ynab4",
budget_base_name).groupdict().get('budget_name')
if args.budgetname is not None:
budget_name = args.budgetname
thisynab = YNAB(budget_path, budget_name)
client = clientfromargs(args, reset=True)
for ynab4_account in thisynab.accounts:
account = Account(
name=ynab4_account.name,
account_type=ynab4_account.type.value,
on_budget=ynab4_account.on_budget,
sortable_index=random.randint(-50000, 50000),
)
mindate = min([
ynab4transaction.date for ynab4transaction in thisynab.transactions
if ynab4transaction.account == ynab4_account
])
client.add_account(account, 0, mindate)
for master_category in thisynab.master_categories:
master_entity = MasterCategory(name=master_category.name,
sortable_index=random.randint(
-50000, 50000))
client.budget.be_master_categories.append(master_entity)
for category in master_category.categories:
entity = Subcategory(name=category.name,
entities_master_category_id=master_entity.id,
sortable_index=random.randint(-50000, 50000))
client.budget.be_subcategories.append(entity)
client.sync()
for ynab4_payee in thisynab.payees:
payee = Payee(name=ynab4_payee.name)
client.budget.be_payees.append(payee)
client.sync()
for ynab4transaction in thisynab.transactions:
transaction = Transaction()
pass
def getpayee(payeename):
try:
logger.debug('searching for payee %s' % payeename)
return payees[payeename]
except KeyError:
logger.debug('Couldn''t find this payee: %s' % payeename)
payee = Payee(name=payeename)
client.budget.be_payees.append(payee)
return payee
def get_or_create_payee(client, name):
payees = {p.name: p for p in client.budget.be_payees if p.name == name}
if name in payees:
return payees[name]
payee = Payee(name=name)
client.budget.be_payees.append(payee)
client.push(1)
return payee
def util_add_payee_by_name_if_doesnt_exist(client, name):
payees = {p.name: p for p in client.budget.be_payees if p.name == name}
if name in payees:
return payees[name]
payee = Payee(name=name)
client.budget.be_payees.append(payee)
client.sync()
return payee
def getpayee(payee_name):
global delta
try:
LOG.debug('searching for payee %s' % payee_name)
return payees[payee_name]
except KeyError:
LOG.debug('Couldn' 't find this payee: %s' % payee_name)
payee = Payee(name=payee_name)
client.budget.be_payees.append(payee)
delta += 1
return payee
def do_ofximport(args, stmts, client=None):
delta = 0
if client is None:
client = clientfromargs(args)
accounts = client.budget.be_accounts
accountvsnotes = {
account.note: account
for account in accounts if account.note is not None
}
for stmt in stmts:
key = stmt.account.bankid + ' ' + stmt.account.branchid + ' ' + stmt.account.acctid
if all(key not in note for note in accountvsnotes):
if len(accounts) == 0:
print('No accounts available in this budget')
exit(-1)
# ask user input for which bank account this is, then save it into the account note in nYNAB
account = client.select_account_ui()
# Save the selection in the nYNAB account note
addon = 'key[' + key + ']key'
if account.note is not None:
account.note += addon
else:
account.note = addon
else:
for note in accountvsnotes:
if key in note:
account = accountvsnotes[note]
imported_date = datetime.now().date()
for ofx_transaction in stmt.transactions:
payee_name = ofx_transaction.name if ofx_transaction.payee is None else ofx_transaction.payee
try:
payee = next(p for p in client.budget.be_payees
if p.name == payee_name)
except StopIteration:
payee = Payee(name=payee_name)
client.budget.be_payees.append(payee)
delta += 1
# use ftid so we don't import duplicates
if not any(
ofx_transaction.fitid in transaction.memo for
transaction in client.budget.be_transactions
if transaction.memo is not None and
transaction.entities_account_id == account.id):
transaction = Transaction(
date=ofx_transaction.dtposted,
memo=ofx_transaction.memo + ' ' +
ofx_transaction.fitid,
imported_payee=payee_name,
entities_payee_id=payee.id,
imported_date=imported_date,
source="Imported",
check_number=ofx_transaction.checknum,
amount=float(ofx_transaction.trnamt),
entities_account_id=account.id)
client.budget.be_transactions.append(transaction)
delta += 1
return delta
def create_new_payee(name):
return Payee(name=name.decode('utf-8'))
