def account_reconcile(database,
lines=2,
months=6,
config_file=os.environ.get('TRYTOND_CONFIG')):
pref = config.set_trytond(database=database, config_file=config_file)
Module = Model.get('ir.module.module')
Company = Model.get('company.company')
modules = Module.find([
('name', '=', 'account_reconcile'),
])
if not modules:
print t.bold('Module account_reconcile not found')
return
reconcile, = modules
if reconcile.state != 'installed':
Module.install([reconcile.id], pref.context)
Wizard('ir.module.module.install_upgrade').execute('upgrade')
for company in Company.find([]):
print t.bold('Start reconcile for company %s (Lines %s, Months %s)' %
(company.rec_name, lines, months))
with pref.set_context({'company': company.id}):
reconcile = Wizard('account.move_reconcile')
reconcile.form.max_lines = str(lines)
reconcile.form.max_months = months
reconcile.form.start_date = None
reconcile.form.end_date = None
reconcile.execute('reconcile')
def InitUser():
Module = Model.get('ir.module.module')
#party
(res, ) = Module.find([('name', '=', 'res')])
Module.install([res.id], config.context)
Wizard('ir.module.module.install_upgrade').execute('upgrade')
(ir, ) = Module.find([('name', '=', 'ir')])
Module.install([ir.id], config.context)
Wizard('ir.module.module.install_upgrade').execute('upgrade')
def crear_company(config, lang):
""" Crear company. Traer datos de AFIP"""
Currency = Model.get('currency.currency')
Company = Model.get('company.company')
Party = Model.get('party.party')
# crear company
# obtener nombre de la compania de un archivo.
print u'\n>>> creando company...'
import ConfigParser
ini_config = ConfigParser.ConfigParser()
ini_config.read('company.ini')
currencies = Currency.find([('code', '=', 'ARS')])
currency, = currencies
company_config = Wizard('company.company.config')
company_config.execute('company')
company = company_config.form
party = Party(name='NOMBRE COMPANY')
party.lang = lang
party.vat_country = 'AR'
try:
party.vat_number = ini_config.get('company', 'cuit')
party.iva_condition = ini_config.get('company', 'iva_condition')
except Exception,e:
print 'Error: No se ha configurado correctamente company.ini\n'
raise SystemExit(repr(e))
def setup_company(config):
Party = Model.get('party.party')
Company = Model.get('company.company')
Currency = Model.get('currency.currency')
Country = Model.get('country.country')
ars, = Currency.find([('code', '=', 'ARS')])
ar, = Country.find([('code', '=', 'AR')])
company_config = Wizard('company.company.config')
company_config.execute('company')
company = company_config.form
party = Party(name='Union Papelera Platense')
party.vat_number = '30709170046'
party.iva_condition = 'responsable_inscripto'
party.save()
company.party = party
company.currency = ars
company_config.execute('add')
# Reload context
User = Model.get('res.user')
config._context = User.get_preferences(True, config.context)
company, = Company.find()
return company
def upgrade_modules(config, modules=None, all=False):
'''
Function get from tryton_demo.py in tryton-tools repo:
http://hg.tryton.org/tryton-tools
'''
assert all or modules
Module = Model.get('ir.module.module')
if all:
modules = Module.find([
('state', '=', 'installed'),
])
else:
modules = Module.find([
('name', 'in', modules),
('state', '=', 'installed'),
])
Module.upgrade([x.id for x in modules], config.context)
Wizard('ir.module.module.install_upgrade').execute('upgrade')
ConfigWizardItem = Model.get('ir.module.module.config_wizard.item')
for item in ConfigWizardItem.find([('state', '!=', 'done')]):
item.state = 'done'
item.save()
upgraded_modules = [
x.name for x in Module.find([
('state', '=', 'to_upgrade'),
])
]
return upgraded_modules
def install_modules():
print u'\n>>> instalando modulos...'
Module = Model.get('ir.module.module')
modules_to_install=[
'account_ar',
'account_voucher_ar',
'account_check_ar',
'account_bank_ar',
'account_retencion_ar',
'account_coop_ar',
'company_logo',
'account_invoice_ar',
]
modules = Module.find([
('name', 'in', modules_to_install),
])
for module in modules:
module.click('install')
Wizard('ir.module.module.install_upgrade').execute('upgrade')
print u'\n>>> wizards de configuracion se marcan como done...'
ConfigWizardItem = Model.get('ir.module.module.config_wizard.item')
for item in ConfigWizardItem.find([('state', '!=', 'done')]):
item.state = 'done'
item.save()
def setup_company(config):
Party = Model.get('party.party')
Company = Model.get('company.company')
Currency = Model.get('currency.currency')
Country = Model.get('country.country')
ars, = Currency.find([('code', '=', 'ARS')])
rate = ars.rates.new()
rate.date = datetime.date(TODAY.year, 1, 1)
rate.rate = Decimal('44.30')
ars.save()
ar, = Country.find([('code', '=', 'AR')])
company_config = Wizard('company.company.config')
company_config.execute('company')
company = company_config.form
party = Party(name='Cooperativa de Trabajo La Metalurgica LTDA')
party.vat_number = '30710288565'
party.iva_condition = 'responsable_inscripto'
party.save()
company.party = party
company.currency = ars
company_config.execute('add')
# Reload context
User = Model.get('res.user')
config._context = User.get_preferences(True, {})
company, = Company.find()
return company
def LoadPlanNIIF():
AccountC = Model.get('account.create_chart.account')
Company = Model.get('company.company')
empresa = '1191758435001'
Template = Model.get('account.account.template')
Account = Model.get('account.account')
account = Account()
account_template = Template.find([('name', '=',
'PLAN DE CUENTAS NIIF ECUADOR'),
('parent', '=', None)])
if len(account_template) == 1:
account_t, = account_template
account_template = account_t
if len(Company.find([('party.vat_number', '=', empresa)])) == 1:
company, = Company.find([('party.vat_number', '=', empresa)])
company = company
create_chart = Wizard('account.create_chart')
create_chart.execute('account')
create_chart.form.account_template = account_template
create_chart.form.company = company
create_chart.execute('create_account')
print "Created chart account"
def test_translation_clean(self):
translation_clean = Wizard('ir.translation.clean')
self.assertEqual(translation_clean.form.__class__.__name__,
'ir.translation.clean.start')
translation_clean.execute('clean')
self.assertEqual(translation_clean.form.__class__.__name__,
'ir.translation.clean.succeed')
def create_chart(company=None, config=None):
"Create chart of accounts"
AccountTemplate = Model.get('account.account.template', config=config)
ModelData = Model.get('ir.model.data')
if not company:
company = get_company()
data, = ModelData.find([
('module', '=', 'account'),
('fs_id', '=', 'account_template_root_en'),
],
limit=1)
account_template = AccountTemplate(data.db_id)
create_chart = Wizard('account.create_chart')
create_chart.execute('account')
create_chart.form.account_template = account_template
create_chart.form.company = company
create_chart.execute('create_account')
accounts = get_accounts(company, config=config)
create_chart.form.account_receivable = accounts['receivable']
create_chart.form.account_payable = accounts['payable']
create_chart.execute('create_properties')
return create_chart
def install_modules(config, modules):
'''
Function get from tryton_demo.py in tryton-tools repo:
http://hg.tryton.org/tryton-tools
'''
Module = Model.get('ir.module.module')
modules = Module.find([
('name', 'in', modules),
#('state', '!=', 'installed'),
])
Module.install([x.id for x in modules], config.context)
modules = [
x.name for x in Module.find([
('state', 'in', ('to install', 'to_upgrade')),
])
]
Wizard('ir.module.module.install_upgrade').execute('upgrade')
ConfigWizardItem = Model.get('ir.module.module.config_wizard.item')
for item in ConfigWizardItem.find([('state', '!=', 'done')]):
item.state = 'done'
item.save()
installed_modules = [
m.name for m in Module.find([('state', '=', 'installed')])
]
return modules, installed_modules
def automatic_reconciliation(database,
max_lines=4,
config_file=os.environ.get('TRYTOND_CONFIG')):
"""
Launch Automatic Reconciliation wizard for all databases and years
"""
if not database:
return
print t.bold("Automatic Reconciliation for %s" % database)
if not check_database(database, {}):
return
config = pconfig.set_trytond(database=database, config_file=config_file)
Company = Model.get('company.company')
FiscalYear = Model.get('account.fiscalyear')
User = Model.get('res.user')
companies = Company.find([])
fiscal_years = FiscalYear.find([('state', '=', 'open')])
print(
"It will reconcile %d companies and %d years. Do you want to "
"continue? [yN]" % (len(companies), len(fiscal_years)))
confirmation = sys.stdin.read(1)
if confirmation != "y":
return
user = User(config.user)
original_company = user.main_company
for company in companies:
print " - Reconcile company %s" % (company.rec_name)
user.main_company = company
user.save()
config._context = User.get_preferences(True, config.context)
for fiscal_year in FiscalYear.find([
('company', '=', company.id),
('state', '=', 'open'),
]):
for max_lines in (2, 3, 4):
print " - Reconcile year %s using %s lines" % (
fiscal_year.name, max_lines)
automatic_reconcile = Wizard('account.move_reconcile')
assert automatic_reconcile.form.company == company, \
'Unexpected company "%s" (%s)' % (
automatic_reconcile.form.company, company)
# get accounts and parties field to avoid
# "Model has no attribute 'accounts'" error
automatic_reconcile.form.accounts
automatic_reconcile.form.parties
automatic_reconcile.form.max_lines = str(max_lines)
automatic_reconcile.form.max_months = 12
automatic_reconcile.form.start_date = fiscal_year.start_date
automatic_reconcile.form.end_date = fiscal_year.end_date
automatic_reconcile.execute('reconcile')
user.main_company = original_company
user.save()
def prepare_translations(ctx,
database,
langs=None,
host=None,
port=None,
dbuser=None,
dbpassword=None,
config_file=os.environ.get('TRYTOND_CONFIG')):
"""
Runs the set, clean and update translations wizards in the given database.
"""
print(
t.bold('prepare_translations: database=%s, langs=%s') %
(database, langs))
if not _check_database(database, host, port, dbuser, dbpassword):
return
config.set_trytond(database=database, config_file=config_file)
Lang = Model.get('ir.lang')
if langs is None:
languages = Lang.find([
('translatable', '=', True),
])
else:
langs = langs.split(',')
languages = Lang.find([
('code', 'in', langs),
])
if set(langs) != set(l.code for l in languages):
print(t.bold('Invalid languages: %s') % languages)
return
translation_set = Wizard('ir.translation.set')
translation_set.execute('set_')
translation_set.execute('end')
translation_clean = Wizard('ir.translation.clean')
translation_clean.execute('clean')
translation_clean.execute('end')
for language in languages:
translation_update = Wizard('ir.translation.update')
translation_update.form.language = language
translation_update.execute('update')
print("%s translation updated" % language.name)
def test_translation_export(self):
Lang = Model.get('ir.lang')
Module = Model.get('ir.module')
translation_export = Wizard('ir.translation.export')
translation_export.form.language, = Lang.find([('code', '=', 'en')])
translation_export.form.module, = Module.find([('name', '=', 'ir')])
translation_export.execute('export')
self.assertTrue(translation_export.form.file)
translation_export.execute('end')
def setup_account_payment(config, modules, company):
Currency = Model.get('currency.currency')
Journal = Model.get('account.payment.journal')
Line = Model.get('account.move.line')
Payment = Model.get('account.payment')
usd, = Currency.find([('code', '=', 'USD')])
journal = Journal(name='Manual',
currency=usd,
company=company,
process_method='manual')
journal.save()
lines = Line.find([
('account.kind', '=', 'payable'),
('party', '!=', None),
('reconciliation', '=', None),
('payment_amount', '!=', 0),
])
lines = random.sample(lines, len(lines) * 2 // 3)
if not lines:
return
pay_line = Wizard('account.move.line.pay', lines)
pay_line.form.journal = journal
pay_line.execute('start')
payments = Payment.find([])
payments = random.sample(payments, len(payments) * 2 // 3)
for payment in payments:
payment.click('approve')
payments = random.sample(payments, len(payments) * 2 // 3)
i = j = 0
while i < len(payments):
j = random.randint(1, 5)
process = Wizard('account.payment.process', payments[i:i + j])
process.execute('process')
i += j
def InitDatabase():
Module = Model.get('ir.module.module')
inicio = 4
for i in range(inicio - 1):
modules.next()
for index, row in enumerate(modules):
print row[0]
name = row[0]
(module, ) = Module.find([('name', '=', name)])
Module.install([module.id], config.context)
Wizard('ir.module.module.install_upgrade').execute('upgrade')
def activate_modules(self, activate_modules):
Module = Model.get('ir.module')
available_modules = Module.find([('name', 'in', activate_modules)])
missing_modules = (set(activate_modules) -
set([m.name for m in available_modules]))
if missing_modules:
logger.warning("some trytond modules are not available for "
"activation: {missing_modules}".format(
missing_modules=missing_modules))
for module in available_modules:
module.click('activate')
Wizard('ir.module.activate_upgrade').execute('upgrade')
def uninstall_task(database,
modules,
config_file=os.environ.get('TRYTOND_CONFIG')):
"""
Uninstall the supplied modules (separated by coma) from database.
"""
if not database or not modules:
return
if isinstance(modules, basestring):
modules = modules.replace(" ", "").split(',')
if not modules:
return
print t.bold("uninstall: ") + ", ".join(modules)
if not check_database(database, {}):
return
config = pconfig.set_trytond(database=database, config_file=config_file)
if proteus_version < '3.5':
Module = Model.get('ir.module.module')
else:
Module = Model.get('ir.module')
modules_to_uninstall = Module.find([('name', 'in', modules),
('state', '=', 'installed')])
Module.uninstall([m.id for m in modules_to_uninstall], config.context)
if proteus_version < '3.5':
module_install_upgrade = Wizard('ir.module.module.install_upgrade')
else:
module_install_upgrade = Wizard('ir.module.install_upgrade')
module_install_upgrade.execute('upgrade')
module_install_upgrade.execute('config')
print ""
def create_chart_of_accounts(config,
module,
fs_id,
company,
digits=None,
receivable_code=None,
payable_code=None):
AccountTemplate = Model.get('account.account.template')
Account = Model.get('account.account')
ModelData = Model.get('ir.model.data')
root_accounts = Account.find([('parent', '=', None)])
if root_accounts:
return
data = ModelData.find([('module', '=', module), ('fs_id', '=', fs_id)],
limit=1)
assert len(data) == 1, ('Unexpected num of root templates '
'with name "%s": %s' % (module, fs_id))
account_template = data[0].db_id
create_chart = Wizard('account.create_chart')
create_chart.execute('account')
create_chart.form.account_template = AccountTemplate(account_template)
create_chart.form.company = company
create_chart.form.account_code_digits = digits
create_chart.execute('create_account')
receivable_domain = [
('kind', '=', 'receivable'),
('company', '=', company.id),
]
if receivable_code is not None:
receivable_domain.append(('code', '=', receivable_code))
receivable = Account.find(receivable_domain)
receivable = receivable[0]
payable_domain = [
('kind', '=', 'payable'),
('company', '=', company.id),
]
if payable_code is not None:
payable_domain.append(('code', '=', payable_code))
payable = Account.find(payable_domain)[0]
create_chart.form.account_receivable = receivable
create_chart.form.account_payable = payable
create_chart.execute('create_properties')
def setup_languages(config, modules, demo_password, company=None):
Lang = Model.get('ir.lang')
Module = Model.get('ir.module')
User = Model.get('res.user')
Group = Model.get('res.group')
Action = Model.get('ir.action')
langs = Lang.find([('code', '=', 'es')])
Lang.write([x.id for x in langs], {
'translatable': True,
}, config.context)
Module.upgrade([x.id for x in Module.find([('name', 'in', modules)])],
config.context)
Wizard('ir.module.activate_upgrade').execute('upgrade')
admin = config.user
# Use root to skip password validation
config.user = 0
menu, = Action.find([('usage', '=', 'menu')])
for lang in langs:
if lang.code == 'en':
name = 'Demo'
login = '******'
else:
if lang.code[:2] != lang.code[-2:].lower():
continue
name = 'Demo %s' % lang.name
login = '******' % lang.code[:2]
try:
user, = User.find([('login', '=', login)])
except ValueError:
user = User()
user.name = name
user.login = login
user.password = demo_password
groups = Group.find([
('name', 'not ilike', '%Admin%'),
])
user.groups.extend(groups)
user.language = lang
user.menu = menu
if company:
user.main_company = company
user.company = company
user.save()
config.user = admin
def test_user_config(self):
User = Model.get('res.user')
user_config = Wizard('res.user.config')
user_config.execute('user')
user_config.form.name = 'Foo'
user_config.form.login = '******'
user_config.execute('add')
self.assertEqual(user_config.form.name, None)
self.assertEqual(user_config.form.login, None)
user_config.form.name = 'Bar'
user_config.form.login = '******'
user_config.execute('end')
self.assertTrue(User.find([('name', '=', 'Foo')]))
self.assertFalse(User.find([('name', '=', 'Bar')]))
def create_company(config,
name,
street=None,
zip=None,
city=None,
subdivision_code=None,
country_code='ES',
currency_code='EUR',
phone=None,
website=None):
'''
Based on tryton_demo.py in tryton-tools repo:
http://hg.tryton.org/tryton-tools
'''
Company = Model.get('company.company')
Currency = Model.get('currency.currency')
party = create_party(config,
name,
street=street,
zip=zip,
city=city,
subdivision_code=subdivision_code,
country_code=country_code,
phone=phone,
website=website)
companies = Company.find([('party', '=', party.id)])
if companies:
return companies[0]
currency, = Currency.find([('code', '=', currency_code)])
company_config = Wizard('company.company.config')
company_config.execute('company')
company = company_config.form
company.party = party
company.currency = currency
company_config.execute('add')
# Reload context
User = Model.get('res.user')
config._context = User.get_preferences(True, config.context)
company, = Company.find([('party', '=', party.id)])
return company
def install_modules(modules):
if isinstance(modules, basestring):
modules = [modules]
cache_name = '-'.join(modules)
if restore_db_cache(cache_name):
return _get_config()
drop_create()
cfg = _get_config()
Module = Model.get('ir.module')
modules = Module.find([
('name', 'in', modules),
])
Module.click(modules, 'install')
Wizard('ir.module.install_upgrade').execute('upgrade')
backup_db_cache(cache_name)
return cfg
def activate_modules(modules, cache_file_name=None):
if isinstance(modules, basestring):
modules = [modules]
cache_name = cache_file_name or '-'.join(modules)
if restore_db_cache(cache_name):
return _get_config()
drop_create()
cfg = _get_config()
Module = Model.get('ir.module')
records = Module.find([
('name', 'in', modules),
])
assert len(records) == len(modules)
Module.click(records, 'activate')
Wizard('ir.module.activate_upgrade').execute('upgrade')
backup_db_cache(cache_name)
return cfg
def activate_modules(modules):
if isinstance(modules, basestring):
modules = [modules]
cache_name = '-'.join(modules)
# JCA : restore_db_cache fails if the database already exists
drop_db()
if restore_db_cache(cache_name):
return _get_config()
create_db()
cfg = _get_config()
Module = Model.get('ir.module')
modules = Module.find([
('name', 'in', modules),
])
Module.click(modules, 'activate')
Wizard('ir.module.activate_upgrade').execute('upgrade')
backup_db_cache(cache_name)
return cfg
def install_modules(config, modules):
Module = Model.get('ir.module.module')
modules = Module.find([
('name', 'in', modules),
('state', '!=', 'installed'),
])
Module.install([x.id for x in modules], config.context)
modules = [x.name for x in Module.find([('state', '=', 'to install')])]
Wizard('ir.module.module.install_upgrade').execute('upgrade')
ConfigWizardItem = Model.get('ir.module.module.config_wizard.item')
for item in ConfigWizardItem.find([('state', '!=', 'done')]):
item.state = 'done'
item.save()
installed_modules = [
m.name for m in Module.find([('state', '=', 'installed')])
]
return modules, installed_modules
def pay_bill(self, id):
"""
Makes the payment of the bill
:id: the id of the bill
:return:boolean True if the value is saved
"""
newid = id
try:
invoice = self.Invoice(id=newid)
if 'aid' not in invoice.state: #check if paid
invoice.click('post')
pay = Wizard('account.invoice.pay', [invoice])
pay.form.journal = self.cash_journal
pay.execute('choice')
invoice.reload()
return invoice.state
except Exception:
if settings.level == 10:
logger.exception('raised exception')
return False
def create_chart(company=None, config=None):
"Create chart of accounts"
AccountTemplate = Model.get('account.account.template', config=config)
if not company:
company = get_company()
account_template, = AccountTemplate.find([('parent', '=', None)])
create_chart = Wizard('account.create_chart')
create_chart.execute('account')
create_chart.form.account_template = account_template
create_chart.form.company = company
create_chart.execute('create_account')
accounts = get_accounts(company, config=config)
create_chart.form.account_receivable = accounts['receivable']
create_chart.form.account_payable = accounts['payable']
create_chart.execute('create_properties')
return create_chart
def create_company(party=None, currency=None, config=None):
"Create the company using the proteus config"
Party = Model.get('party.party', config=config)
User = Model.get('res.user', config=config)
company_config = Wizard('company.company.config')
company_config.execute('company')
company = company_config.form
if not party:
party = Party(name='Dunder Mifflin')
party.save()
company.party = party
if not currency:
currency = get_currency()
company.currency = currency
company_config.execute('add')
if not config:
config = get_config()
config._context = User.get_preferences(True, {})
return company_config
def activate_modules(config, modules):
Module = Model.get('ir.module')
modules = Module.find([
('name', 'in', modules),
])
for module in modules:
if module.state == 'activated':
module.click('upgrade')
else:
module.click('activate')
modules = [x.name for x in Module.find([('state', '=', 'to activate')])]
Wizard('ir.module.activate_upgrade').execute('upgrade')
ConfigWizardItem = Model.get('ir.module.config_wizard.item')
for item in ConfigWizardItem.find([('state', '!=', 'done')]):
item.state = 'done'
item.save()
activated_modules = [m.name
for m in Module.find([('state', '=', 'activated')])]
return modules, activated_modules
