#
##############################################################################
-import time
+import logging
from datetime import datetime
from dateutil.relativedelta import relativedelta
from operator import itemgetter
+import time
+
+from openerp import SUPERUSER_ID
+from openerp import pooler, tools
+from openerp.osv import fields, osv
+from openerp.tools.translate import _
+from openerp.tools.float_utils import float_round
+
+import openerp.addons.decimal_precision as dp
-import netsvc
-import pooler
-from osv import fields, osv
-import decimal_precision as dp
-from tools.translate import _
+_logger = logging.getLogger(__name__)
def check_cycle(self, cr, uid, ids, context=None):
""" climbs the ``self._table.parent_id`` chains for 100 levels or
amount = value
result = []
obj_precision = self.pool.get('decimal.precision')
+ prec = obj_precision.precision_get(cr, uid, 'Account')
for line in pt.line_ids:
- prec = obj_precision.precision_get(cr, uid, 'Account')
if line.value == 'fixed':
amt = round(line.value_amount, prec)
elif line.value == 'procent':
next_date += relativedelta(day=line.days2, months=1)
result.append( (next_date.strftime('%Y-%m-%d'), amt) )
amount -= amt
- return result
-account_payment_term()
+ amount = reduce(lambda x,y: x+y[1], result, 0.0)
+ dist = round(value-amount, prec)
+ if dist:
+ result.append( (time.strftime('%Y-%m-%d'), dist) )
+ return result
class account_payment_term_line(osv.osv):
_name = "account.payment.term.line"
_description = "Payment Term Line"
_columns = {
- 'name': fields.char('Line Name', size=32, required=True),
- 'sequence': fields.integer('Sequence', required=True, help="The sequence field is used to order the payment term lines from the lowest sequences to the higher ones"),
'value': fields.selection([('procent', 'Percent'),
('balance', 'Balance'),
- ('fixed', 'Fixed Amount')], 'Valuation',
- required=True, help="""Select here the kind of valuation related to this payment term line. Note that you should have your last line with the type 'Balance' to ensure that the whole amount will be threated."""),
+ ('fixed', 'Fixed Amount')], 'Computation',
+ required=True, help="""Select here the kind of valuation related to this payment term line. Note that you should have your last line with the type 'Balance' to ensure that the whole amount will be treated."""),
'value_amount': fields.float('Amount To Pay', digits_compute=dp.get_precision('Payment Term'), help="For percent enter a ratio between 0-1."),
'days': fields.integer('Number of Days', required=True, help="Number of days to add before computation of the day of month." \
"If Date=15/01, Number of Days=22, Day of Month=-1, then the due date is 28/02."),
'days2': fields.integer('Day of the Month', required=True, help="Day of the month, set -1 for the last day of the current month. If it's positive, it gives the day of the next month. Set 0 for net days (otherwise it's based on the beginning of the month)."),
- 'payment_id': fields.many2one('account.payment.term', 'Payment Term', required=True, select=True),
+ 'payment_id': fields.many2one('account.payment.term', 'Payment Term', required=True, select=True, ondelete='cascade'),
}
_defaults = {
'value': 'balance',
- 'sequence': 5,
+ 'days': 30,
'days2': 0,
}
- _order = "sequence"
+ _order = "value desc,days"
def _check_percent(self, cr, uid, ids, context=None):
obj = self.browse(cr, uid, ids[0], context=context)
return True
_constraints = [
- (_check_percent, 'Percentages for Payment Term Line must be between 0 and 1, Example: 0.02 for 2% ', ['value_amount']),
+ (_check_percent, 'Percentages for Payment Term Line must be between 0 and 1, Example: 0.02 for 2%.', ['value_amount']),
]
account_payment_term_line()
def _get_current_report_type(self, cr, uid, ids, name, arg, context=None):
obj_data = self.pool.get('ir.model.data')
- obj_financial_report = self.pool.get('account.financial.report')
+ obj_financial_report = self.pool.get('account.financial.report')
res = {}
financial_report_ref = {
'asset': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_assets0')[1], context=context),
return res
def _save_report_type(self, cr, uid, account_type_id, field_name, field_value, arg, context=None):
+ field_value = field_value or 'none'
obj_data = self.pool.get('ir.model.data')
- obj_financial_report = self.pool.get('account.financial.report')
+ obj_financial_report = self.pool.get('account.financial.report')
#unlink if it exists somewhere in the financial reports related to BS or PL
financial_report_ref = {
'asset': obj_financial_report.browse(cr, uid, obj_data.get_object_reference(cr, uid, 'account','account_financial_report_assets0')[1], context=context),
'Balance' will generally be used for cash accounts.
'Detail' will copy each existing journal item of the previous year, even the reconciled ones.
'Unreconciled' will copy only the journal items that were unreconciled on the first day of the new fiscal year."""),
- 'report_type': fields.function(_get_current_report_type, fnct_inv=_save_report_type, type='selection', string='P&L / BS Category',
+ 'report_type': fields.function(_get_current_report_type, fnct_inv=_save_report_type, type='selection', string='P&L / BS Category', store=True,
selection= [('none','/'),
('income', _('Profit & Loss (Income account)')),
('expense', _('Profit & Loss (Expense account)')),
_name = "account.account"
_description = "Account"
_parent_store = True
- logger = netsvc.Logger()
def search(self, cr, uid, args, offset=0, limit=None, order=None,
context=None, count=False):
while pos < len(args):
if args[pos][0] == 'code' and args[pos][1] in ('like', 'ilike') and args[pos][2]:
- args[pos] = ('code', '=like', str(args[pos][2].replace('%', ''))+'%')
+ args[pos] = ('code', '=like', tools.ustr(args[pos][2].replace('%', ''))+'%')
if args[pos][0] == 'journal_id':
if not args[pos][2]:
del args[pos]
if aml_query.strip():
wheres.append(aml_query.strip())
filters = " AND ".join(wheres)
- self.logger.notifyChannel('addons.'+self._name, netsvc.LOG_DEBUG,
- 'Filters: %s'%filters)
# IN might not work ideally in case there are too many
# children_and_consolidated, in that case join on a
# values() e.g.:
" GROUP BY l.account_id")
params = (tuple(children_and_consolidated),) + query_params
cr.execute(request, params)
- self.logger.notifyChannel('addons.'+self._name, netsvc.LOG_DEBUG,
- 'Status: %s'%cr.statusmessage)
- for res in cr.dictfetchall():
- accounts[res['id']] = res
+ for row in cr.dictfetchall():
+ accounts[row['id']] = row
# consolidate accounts with direct children
children_and_consolidated.reverse()
journal_obj = self.pool.get('account.journal')
jids = journal_obj.search(cr, uid, [('type','=','situation'),('centralisation','=',1),('company_id','=',account.company_id.id)], context=context)
if not jids:
- raise osv.except_osv(_('Error!'),_("You need an Opening journal with centralisation checked to set the initial balance!"))
+ raise osv.except_osv(_('Error!'),_("You need an Opening journal with centralisation checked to set the initial balance."))
period_obj = self.pool.get('account.period')
pids = period_obj.search(cr, uid, [('special','=',True),('company_id','=',account.company_id.id)], context=context)
if not pids:
- raise osv.except_osv(_('Error!'),_("No opening/closing period defined, please create one to set the initial balance!"))
+ raise osv.except_osv(_('Error!'),_("There is no opening/closing period defined, please create one to set the initial balance."))
move_obj = self.pool.get('account.move.line')
move_id = move_obj.search(cr, uid, [
}, context=context)
else:
if diff<0.0:
- raise osv.except_osv(_('Error!'),_("Unable to adapt the initial balance (negative value)!"))
+ raise osv.except_osv(_('Error!'),_("Unable to adapt the initial balance (negative value)."))
nameinv = (name=='credit' and 'debit') or 'credit'
move_id = move_obj.create(cr, uid, {
'name': _('Opening Balance'),
'shortcut': fields.char('Shortcut', size=12),
'tax_ids': fields.many2many('account.tax', 'account_account_tax_default_rel',
'account_id', 'tax_id', 'Default Taxes'),
- 'note': fields.text('Note'),
+ 'note': fields.text('Internal Notes'),
'company_currency_id': fields.function(_get_company_currency, type='many2one', relation='res.currency', string='Company Currency'),
'company_id': fields.many2one('res.company', 'Company', required=True),
'active': fields.boolean('Active', select=2, help="If the active field is set to False, it will allow you to hide the account without removing it."),
return False
return True
+ def _check_company_account(self, cr, uid, ids, context=None):
+ for account in self.browse(cr, uid, ids, context=context):
+ if account.parent_id:
+ if account.company_id != account.parent_id.company_id:
+ return False
+ return True
+
_constraints = [
- (_check_recursion, 'Error ! You can not create recursive accounts.', ['parent_id']),
- (_check_type, 'Configuration Error! \nYou can not define children to an account with internal type different of "View"! ', ['type']),
- (_check_account_type, 'Configuration Error! \nYou can not select an account type with a deferral method different of "Unreconciled" for accounts with internal type "Payable/Receivable"! ', ['user_type','type']),
+ (_check_recursion, 'Error!\nYou cannot create recursive accounts.', ['parent_id']),
+ (_check_type, 'Configuration Error!\nYou cannot define children to an account with internal type different of "View".', ['type']),
+ (_check_account_type, 'Configuration Error!\nYou cannot select an account type with a deferral method different of "Unreconciled" for accounts with internal type "Payable/Receivable".', ['user_type','type']),
+ (_check_company_account, 'Error!\nYou cannot create an account which has parent account of different company.', ['parent_id']),
]
_sql_constraints = [
('code_company_uniq', 'unique (code,company_id)', 'The code of the account must be unique per company !')
def name_get(self, cr, uid, ids, context=None):
if not ids:
return []
+ if isinstance(ids, (int, long)):
+ ids = [ids]
reads = self.read(cr, uid, ids, ['name', 'code'], context=context)
res = []
for record in reads:
res.append((record['id'], name))
return res
- def copy(self, cr, uid, id, default={}, context=None, done_list=[], local=False):
+ def copy(self, cr, uid, id, default=None, context=None, done_list=None, local=False):
+ default = {} if default is None else default.copy()
+ if done_list is None:
+ done_list = []
account = self.browse(cr, uid, id, context=context)
new_child_ids = []
- if not default:
- default = {}
- default = default.copy()
- default['code'] = (account['code'] or '') + '(copy)'
+ default.update(code=_("%s (copy)") % (account['code'] or ''))
if not local:
done_list = []
if account.id in done_list:
if line_obj.search(cr, uid, [('account_id', 'in', account_ids)]):
if method == 'write':
- raise osv.except_osv(_('Error !'), _('You can not desactivate an account that contains some journal items.'))
+ raise osv.except_osv(_('Error!'), _('You cannot deactivate an account that contains journal items.'))
elif method == 'unlink':
- raise osv.except_osv(_('Error !'), _('You can not remove an account containing journal items.'))
+ raise osv.except_osv(_('Error!'), _('You cannot remove an account that contains journal items.'))
#Checking whether the account is set as a property to any Partner or not
value = 'account.account,' + str(ids[0])
partner_prop_acc = self.pool.get('ir.property').search(cr, uid, [('value_reference','=',value)], context=context)
if partner_prop_acc:
- raise osv.except_osv(_('Warning !'), _('You can not remove/desactivate an account which is set on a customer or supplier.'))
+ raise osv.except_osv(_('Warning!'), _('You cannot remove/deactivate an account which is set on a customer or supplier.'))
return True
def _check_allow_type_change(self, cr, uid, ids, new_type, context=None):
- group1 = ['payable', 'receivable', 'other']
- group2 = ['consolidation','view']
+ restricted_groups = ['consolidation','view']
line_obj = self.pool.get('account.move.line')
for account in self.browse(cr, uid, ids, context=context):
old_type = account.type
if line_obj.search(cr, uid, [('account_id', 'in', account_ids)]):
#Check for 'Closed' type
if old_type == 'closed' and new_type !='closed':
- raise osv.except_osv(_('Warning !'), _("You cannot change the type of account from 'Closed' to any other type which contains journal items!"))
- #Check for change From group1 to group2 and vice versa
- if (old_type in group1 and new_type in group2) or (old_type in group2 and new_type in group1):
- raise osv.except_osv(_('Warning !'), _("You cannot change the type of account from '%s' to '%s' type as it contains journal items!") % (old_type,new_type,))
+ raise osv.except_osv(_('Warning !'), _("You cannot change the type of account from 'Closed' to any other type as it contains journal items!"))
+ # Forbid to change an account type for restricted_groups as it contains journal items (or if one of its children does)
+ if (new_type in restricted_groups):
+ raise osv.except_osv(_('Warning !'), _("You cannot change the type of account to '%s' type as it contains journal items!") % (new_type,))
+
return True
- def write(self, cr, uid, ids, vals, context=None):
+ # For legal reason (forbiden to modify journal entries which belongs to a closed fy or period), Forbid to modify
+ # the code of an account if journal entries have been already posted on this account. This cannot be simply
+ # 'configurable' since it can lead to a lack of confidence in OpenERP and this is what we want to change.
+ def _check_allow_code_change(self, cr, uid, ids, context=None):
+ line_obj = self.pool.get('account.move.line')
+ for account in self.browse(cr, uid, ids, context=context):
+ account_ids = self.search(cr, uid, [('id', 'child_of', [account.id])], context=context)
+ if line_obj.search(cr, uid, [('account_id', 'in', account_ids)], context=context):
+ raise osv.except_osv(_('Warning !'), _("You cannot change the code of account which contains journal items!"))
+ return True
+ def write(self, cr, uid, ids, vals, context=None):
if context is None:
context = {}
if not ids:
# Allow the write if the value is the same
for i in [i['company_id'][0] for i in self.read(cr,uid,ids,['company_id'])]:
if vals['company_id']!=i:
- raise osv.except_osv(_('Warning !'), _('You cannot change the owner company of an account that already contains journal items.'))
+ raise osv.except_osv(_('Warning!'), _('You cannot change the owner company of an account that already contains journal items.'))
if 'active' in vals and not vals['active']:
self._check_moves(cr, uid, ids, "write", context=context)
if 'type' in vals.keys():
self._check_allow_type_change(cr, uid, ids, vals['type'], context=context)
+ if 'code' in vals.keys():
+ self._check_allow_code_change(cr, uid, ids, context=context)
return super(account_account, self).write(cr, uid, ids, vals, context=context)
def unlink(self, cr, uid, ids, context=None):
account_account()
-class account_journal_view(osv.osv):
- _name = "account.journal.view"
- _description = "Journal View"
- _columns = {
- 'name': fields.char('Journal View', size=64, required=True),
- 'columns_id': fields.one2many('account.journal.column', 'view_id', 'Columns')
- }
- _order = "name"
-
-account_journal_view()
-
-
-class account_journal_column(osv.osv):
-
- def _col_get(self, cr, user, context=None):
- result = []
- cols = self.pool.get('account.move.line')._columns
- for col in cols:
- if col in ('period_id', 'journal_id'):
- continue
- result.append( (col, cols[col].string) )
- result.sort()
- return result
-
- _name = "account.journal.column"
- _description = "Journal Column"
- _columns = {
- 'name': fields.char('Column Name', size=64, required=True),
- 'field': fields.selection(_col_get, 'Field Name', required=True, size=32),
- 'view_id': fields.many2one('account.journal.view', 'Journal View', select=True),
- 'sequence': fields.integer('Sequence', help="Gives the sequence order to journal column.", readonly=True),
- 'required': fields.boolean('Required'),
- 'readonly': fields.boolean('Readonly'),
- }
- _order = "view_id, sequence"
-
-account_journal_column()
-
class account_journal(osv.osv):
_name = "account.journal"
_description = "Journal"
_columns = {
+ 'with_last_closing_balance' : fields.boolean('Opening With Last Closing Balance'),
'name': fields.char('Journal Name', size=64, required=True),
'code': fields.char('Code', size=5, required=True, help="The code will be displayed on reports."),
- 'type': fields.selection([('sale', 'Sale'),('sale_refund','Sale Refund'), ('purchase', 'Purchase'), ('purchase_refund','Purchase Refund'), ('cash', 'Cash'), ('bank', 'Bank and Cheques'), ('general', 'General'), ('situation', 'Opening/Closing Situation')], 'Type', size=32, required=True,
+ 'type': fields.selection([('sale', 'Sale'),('sale_refund','Sale Refund'), ('purchase', 'Purchase'), ('purchase_refund','Purchase Refund'), ('cash', 'Cash'), ('bank', 'Bank and Checks'), ('general', 'General'), ('situation', 'Opening/Closing Situation')], 'Type', size=32, required=True,
help="Select 'Sale' for customer invoices journals."\
" Select 'Purchase' for supplier invoices journals."\
" Select 'Cash' or 'Bank' for journals that are used in customer or supplier payments."\
" Select 'Opening/Closing Situation' for entries generated for new fiscal years."),
'type_control_ids': fields.many2many('account.account.type', 'account_journal_type_rel', 'journal_id','type_id', 'Type Controls', domain=[('code','<>','view'), ('code', '<>', 'closed')]),
'account_control_ids': fields.many2many('account.account', 'account_account_type_rel', 'journal_id','account_id', 'Account', domain=[('type','<>','view'), ('type', '<>', 'closed')]),
- 'view_id': fields.many2one('account.journal.view', 'Display Mode', required=True, help="Gives the view used when writing or browsing entries in this journal. The view tells OpenERP which fields should be visible, required or readonly and in which order. You can create your own view for a faster encoding in each journal."),
'default_credit_account_id': fields.many2one('account.account', 'Default Credit Account', domain="[('type','!=','view')]", help="It acts as a default account for credit amount"),
'default_debit_account_id': fields.many2one('account.account', 'Default Debit Account', domain="[('type','!=','view')]", help="It acts as a default account for debit amount"),
- 'centralisation': fields.boolean('Centralised counterpart', help="Check this box to determine that each entry of this journal won't create a new counterpart but will share the same counterpart. This is used in fiscal year closing."),
+ 'centralisation': fields.boolean('Centralized Counterpart', help="Check this box to determine that each entry of this journal won't create a new counterpart but will share the same counterpart. This is used in fiscal year closing."),
'update_posted': fields.boolean('Allow Cancelling Entries', help="Check this box if you want to allow the cancellation the entries related to this journal or of the invoice related to this journal"),
'group_invoice_lines': fields.boolean('Group Invoice Lines', help="If this box is checked, the system will try to group the accounting lines when generating them from invoices."),
- 'sequence_id': fields.many2one('ir.sequence', 'Entry Sequence', help="This field contains the informatin related to the numbering of the journal entries of this journal.", required=True),
+ 'sequence_id': fields.many2one('ir.sequence', 'Entry Sequence', help="This field contains the information related to the numbering of the journal entries of this journal.", required=True),
'user_id': fields.many2one('res.users', 'User', help="The user responsible for this journal"),
'groups_id': fields.many2many('res.groups', 'account_journal_group_rel', 'journal_id', 'group_id', 'Groups'),
'currency': fields.many2one('res.currency', 'Currency', help='The currency used to enter statement'),
'entry_posted': fields.boolean('Skip \'Draft\' State for Manual Entries', help='Check this box if you don\'t want new journal entries to pass through the \'draft\' state and instead goes directly to the \'posted state\' without any manual validation. \nNote that journal entries that are automatically created by the system are always skipping that state.'),
'company_id': fields.many2one('res.company', 'Company', required=True, select=1, help="Company related to this journal"),
'allow_date':fields.boolean('Check Date in Period', help= 'If set to True then do not accept the entry if the entry date is not into the period dates'),
+
+ 'profit_account_id' : fields.many2one('account.account', 'Profit Account'),
+ 'loss_account_id' : fields.many2one('account.account', 'Loss Account'),
+ 'internal_account_id' : fields.many2one('account.account', 'Internal Transfers Account', select=1),
+ 'cash_control' : fields.boolean('Cash Control', help='If you want the journal should be control at opening/closing, check this option'),
}
_defaults = {
+ 'cash_control' : False,
+ 'with_last_closing_balance' : False,
'user_id': lambda self, cr, uid, context: uid,
'company_id': lambda self, cr, uid, c: self.pool.get('res.users').browse(cr, uid, uid, c).company_id.id,
}
return True
_constraints = [
- (_check_currency, 'Configuration error! The currency chosen should be shared by the default accounts too.', ['currency','default_debit_account_id','default_credit_account_id']),
+ (_check_currency, 'Configuration error!\nThe currency chosen should be shared by the default accounts too.', ['currency','default_debit_account_id','default_credit_account_id']),
]
- def copy(self, cr, uid, id, default={}, context=None, done_list=[], local=False):
+ def copy(self, cr, uid, id, default=None, context=None, done_list=None, local=False):
+ default = {} if default is None else default.copy()
+ if done_list is None:
+ done_list = []
journal = self.browse(cr, uid, id, context=context)
- if not default:
- default = {}
- default = default.copy()
- default['code'] = (journal['code'] or '') + '(copy)'
- default['name'] = (journal['name'] or '') + '(copy)'
- default['sequence_id'] = False
+ default.update(
+ code=_("%s (copy)") % (journal['code'] or ''),
+ name=_("%s (copy)") % (journal['name'] or ''),
+ sequence_id=False)
return super(account_journal, self).copy(cr, uid, id, default, context=context)
def write(self, cr, uid, ids, vals, context=None):
if 'company_id' in vals and journal.company_id.id != vals['company_id']:
move_lines = self.pool.get('account.move.line').search(cr, uid, [('journal_id', 'in', ids)])
if move_lines:
- raise osv.except_osv(_('Warning !'), _('You can not modify the company of this journal as its related record exist in journal items'))
+ raise osv.except_osv(_('Warning!'), _('This journal already contains items, therefore you cannot modify its company field.'))
return super(account_journal, self).write(cr, uid, ids, vals, context=context)
def create_sequence(self, cr, uid, vals, context=None):
if not 'sequence_id' in vals or not vals['sequence_id']:
# if we have the right to create a journal, we should be able to
# create it's sequence.
- vals.update({'sequence_id': self.create_sequence(cr, 1, vals, context)})
+ vals.update({'sequence_id': self.create_sequence(cr, SUPERUSER_ID, vals, context)})
return super(account_journal, self).create(cr, uid, vals, context)
def name_get(self, cr, user, ids, context=None):
@return: Returns a list of tupples containing id, name
"""
+ if not ids:
+ return []
+ if isinstance(ids, (int, long)):
+ ids = [ids]
result = self.browse(cr, user, ids, context=context)
res = []
for rs in result:
return self.name_get(cr, user, ids, context=context)
- def onchange_type(self, cr, uid, ids, type, currency, context=None):
- obj_data = self.pool.get('ir.model.data')
- user_pool = self.pool.get('res.users')
-
- type_map = {
- 'sale':'account_sp_journal_view',
- 'sale_refund':'account_sp_refund_journal_view',
- 'purchase':'account_sp_journal_view',
- 'purchase_refund':'account_sp_refund_journal_view',
- 'cash':'account_journal_bank_view',
- 'bank':'account_journal_bank_view',
- 'general':'account_journal_view',
- 'situation':'account_journal_view'
- }
-
- res = {}
- view_id = type_map.get(type, 'account_journal_view')
- user = user_pool.browse(cr, uid, uid)
- if type in ('cash', 'bank') and currency and user.company_id.currency_id.id != currency:
- view_id = 'account_journal_bank_view_multi'
- data_id = obj_data.search(cr, uid, [('model','=','account.journal.view'), ('name','=',view_id)])
- data = obj_data.browse(cr, uid, data_id[0], context=context)
-
- res.update({
- 'centralisation':type == 'situation',
- 'view_id':data.res_id,
- })
- return {
- 'value':res
- }
-
account_journal()
class account_fiscalyear(osv.osv):
'date_start': fields.date('Start Date', required=True),
'date_stop': fields.date('End Date', required=True),
'period_ids': fields.one2many('account.period', 'fiscalyear_id', 'Periods'),
- 'state': fields.selection([('draft','Open'), ('done','Closed')], 'State', readonly=True),
+ 'state': fields.selection([('draft','Open'), ('done','Closed')], 'Status', readonly=True),
}
_defaults = {
'state': 'draft',
return True
_constraints = [
- (_check_duration, 'Error! The start date of the fiscal year must be before his end date.', ['date_start','date_stop'])
+ (_check_duration, 'Error!\nThe start date of a fiscal year must precede its end date.', ['date_start','date_stop'])
]
def create_period3(self, cr, uid, ids, context=None):
ids = self.search(cr, uid, args, context=context)
if not ids:
if exception:
- raise osv.except_osv(_('Error !'), _('No fiscal year defined for this date !\nPlease create one from the configuration of the accounting menu.'))
+ raise osv.except_osv(_('Error!'), _('There is no fiscal year defined for this date.\nPlease create one from the configuration of the accounting menu.'))
else:
return []
return ids
'date_start': fields.date('Start of Period', required=True, states={'done':[('readonly',True)]}),
'date_stop': fields.date('End of Period', required=True, states={'done':[('readonly',True)]}),
'fiscalyear_id': fields.many2one('account.fiscalyear', 'Fiscal Year', required=True, states={'done':[('readonly',True)]}, select=True),
- 'state': fields.selection([('draft','Open'), ('done','Closed')], 'State', readonly=True,
- help='When monthly periods are created. The state is \'Draft\'. At the end of monthly period it is in \'Done\' state.'),
+ 'state': fields.selection([('draft','Open'), ('done','Closed')], 'Status', readonly=True,
+ help='When monthly periods are created. The status is \'Draft\'. At the end of monthly period it is in \'Done\' status.'),
'company_id': fields.related('fiscalyear_id', 'company_id', type='many2one', relation='res.company', string='Company', store=True, readonly=True)
}
_defaults = {
return True
_constraints = [
- (_check_duration, 'Error ! The duration of the Period(s) is/are invalid. ', ['date_stop']),
- (_check_year_limit, 'Invalid period ! Some periods overlap or the date period is not in the scope of the fiscal year. ', ['date_stop'])
+ (_check_duration, 'Error!\nThe duration of the Period(s) is/are invalid.', ['date_stop']),
+ (_check_year_limit, 'Error!\nThe period is invalid. Either some periods are overlapping or the period\'s dates are not matching the scope of the fiscal year.', ['date_stop'])
]
def next(self, cr, uid, period, step, context=None):
if not result:
result = self.search(cr, uid, args, context=context)
if not result:
- raise osv.except_osv(_('Error !'), _('No period defined for this date: %s !\nPlease create one.')%dt)
+ raise osv.except_osv(_('Error !'), _('There is no period defined for this date: %s.\nPlease create one.')%dt)
return result
def action_draft(self, cr, uid, ids, *args):
if 'company_id' in vals:
move_lines = self.pool.get('account.move.line').search(cr, uid, [('period_id', 'in', ids)])
if move_lines:
- raise osv.except_osv(_('Warning !'), _('You can not modify company of this period as some journal items exists.'))
+ raise osv.except_osv(_('Warning!'), _('This journal already contains items for this period, therefore you cannot modify its company field.'))
return super(account_period, self).write(cr, uid, ids, vals, context=context)
def build_ctx_periods(self, cr, uid, period_from_id, period_to_id):
period_date_stop = period_to.date_stop
company2_id = period_to.company_id.id
if company1_id != company2_id:
- raise osv.except_osv(_('Error'), _('You should have chosen periods that belongs to the same company'))
+ raise osv.except_osv(_('Error!'), _('You should choose the periods that belong to the same company.'))
if period_date_start > period_date_stop:
- raise osv.except_osv(_('Error'), _('Start period should be smaller then End period'))
+ raise osv.except_osv(_('Error!'), _('Start period should precede then end period.'))
#for period from = january, we want to exclude the opening period (but it has same date_from, so we have to check if period_from is special or not to include that clause or not in the search).
if period_from.special:
return self.search(cr, uid, [('date_start', '>=', period_date_start), ('date_stop', '<=', period_date_stop), ('company_id', '=', company1_id)])
'journal_id': fields.many2one('account.journal', 'Journal', required=True, ondelete="cascade"),
'period_id': fields.many2one('account.period', 'Period', required=True, ondelete="cascade"),
'icon': fields.function(_icon_get, string='Icon', type='char', size=32),
- 'active': fields.boolean('Active', required=True, help="If the active field is set to False, it will allow you to hide the journal period without removing it."),
- 'state': fields.selection([('draft','Draft'), ('printed','Printed'), ('done','Done')], 'State', required=True, readonly=True,
- help='When journal period is created. The state is \'Draft\'. If a report is printed it comes to \'Printed\' state. When all transactions are done, it comes in \'Done\' state.'),
+ 'active': fields.boolean('Active', help="If the active field is set to False, it will allow you to hide the journal period without removing it."),
+ 'state': fields.selection([('draft','Draft'), ('printed','Printed'), ('done','Done')], 'Status', required=True, readonly=True,
+ help='When journal period is created. The status is \'Draft\'. If a report is printed it comes to \'Printed\' status. When all transactions are done, it comes in \'Done\' status.'),
'fiscalyear_id': fields.related('period_id', 'fiscalyear_id', string='Fiscal Year', type='many2one', relation='account.fiscalyear'),
'company_id': fields.related('journal_id', 'company_id', type='many2one', relation='res.company', string='Company', store=True, readonly=True)
}
cr.execute('select * from account_move_line where journal_id=%s and period_id=%s limit 1', (obj.journal_id.id, obj.period_id.id))
res = cr.fetchall()
if res:
- raise osv.except_osv(_('Error !'), _('You can not modify/delete a journal with entries for this period !'))
+ raise osv.except_osv(_('Error!'), _('You cannot modify/delete a journal with entries for this period.'))
return True
def write(self, cr, uid, ids, vals, context=None):
'end_journal_period_id':fields.many2one('account.journal.period','End of Year Entries Journal', readonly=True),
}
- def copy(self, cr, uid, id, default={}, context=None):
+ def copy(self, cr, uid, id, default=None, context=None):
+ default = {} if default is None else default.copy()
default.update({
'period_ids': [],
'end_journal_period_id': False
_description = "Account Entry"
_order = 'id desc'
+ def account_move_prepare(self, cr, uid, journal_id, date=False, ref='', company_id=False, context=None):
+ '''
+ Prepares and returns a dictionary of values, ready to be passed to create() based on the parameters received.
+ '''
+ if not date:
+ date = fields.date.today()
+ period_obj = self.pool.get('account.period')
+ if not company_id:
+ user = self.pool.get('res.users').browse(cr, uid, uid, context=context)
+ company_id = user.company_id.id
+ if context is None:
+ context = {}
+ #put the company in context to find the good period
+ ctx = context.copy()
+ ctx.update({'company_id': company_id})
+ return {
+ 'journal_id': journal_id,
+ 'date': date,
+ 'period_id': period_obj.find(cr, uid, date, context=ctx)[0],
+ 'ref': ref,
+ 'company_id': company_id,
+ }
+
def name_search(self, cr, user, name, args=None, operator='ilike', context=None, limit=80):
"""
Returns a list of tupples containing id, name, as internally it is called {def name_get}
'ref': fields.char('Reference', size=64),
'period_id': fields.many2one('account.period', 'Period', required=True, states={'posted':[('readonly',True)]}),
'journal_id': fields.many2one('account.journal', 'Journal', required=True, states={'posted':[('readonly',True)]}),
- 'state': fields.selection([('draft','Unposted'), ('posted','Posted')], 'State', required=True, readonly=True,
- help='All manually created new journal entries are usually in the state \'Unposted\', but you can set the option to skip that state on the related journal. In that case, they will be behave as journal entries automatically created by the system on document validation (invoices, bank statements...) and will be created in \'Posted\' state.'),
+ 'state': fields.selection([('draft','Unposted'), ('posted','Posted')], 'Status', required=True, readonly=True,
+ help='All manually created new journal entries are usually in the status \'Unposted\', but you can set the option to skip that status on the related journal. In that case, they will behave as journal entries automatically created by the system on document validation (invoices, bank statements...) and will be created in \'Posted\' status.'),
'line_id': fields.one2many('account.move.line', 'move_id', 'Entries', states={'posted':[('readonly',True)]}),
'to_check': fields.boolean('To Review', help='Check this box if you are unsure of that journal entry and if you want to note it as \'to be reviewed\' by an accounting expert.'),
'partner_id': fields.related('line_id', 'partner_id', type="many2one", relation="res.partner", string="Partner", store=True),
_constraints = [
(_check_centralisation,
- 'You can not create more than one move per period on centralized journal',
+ 'You cannot create more than one move per period on a centralized journal.',
['journal_id']),
]
valid_moves = self.validate(cr, uid, ids, context)
if not valid_moves:
- raise osv.except_osv(_('Integrity Error !'), _('You can not validate a non-balanced entry !\nMake sure you have configured payment terms properly !\nThe latest payment term line should be of the type "Balance" !'))
+ raise osv.except_osv(_('Error!'), _('You cannot validate a non-balanced entry.\nMake sure you have configured payment terms properly.\nThe latest payment term line should be of the "Balance" type.'))
obj_sequence = self.pool.get('ir.sequence')
for move in self.browse(cr, uid, valid_moves, context=context):
if move.name =='/':
c = {'fiscalyear_id': move.period_id.fiscalyear_id.id}
new_name = obj_sequence.next_by_id(cr, uid, journal.sequence_id.id, c)
else:
- raise osv.except_osv(_('Error'), _('No sequence defined on the journal !'))
+ raise osv.except_osv(_('Error!'), _('Please define a sequence on the journal.'))
if new_name:
self.write(cr, uid, [move.id], {'name':new_name})
if not top_common:
top_common = top_account
elif top_account.id != top_common.id:
- raise osv.except_osv(_('Error !'),
- _('You cannot validate this journal entry because account "%s" does not belong to chart of accounts "%s"!') % (account.name, top_common.name))
+ raise osv.except_osv(_('Error!'),
+ _('You cannot validate this journal entry because account "%s" does not belong to chart of accounts "%s".') % (account.name, top_common.name))
return self.post(cursor, user, ids, context=context)
def button_cancel(self, cr, uid, ids, context=None):
for line in self.browse(cr, uid, ids, context=context):
- if line.period_id.state == 'done':
- raise osv.except_osv(_('Error !'), _('You can not modify a posted entry of closed periods'))
- elif not line.journal_id.update_posted:
- raise osv.except_osv(_('Error !'), _('You can not modify a posted entry of this journal !\nYou should set the journal to allow cancelling entries if you want to do that.'))
+ if not line.journal_id.update_posted:
+ raise osv.except_osv(_('Error!'), _('You cannot modify a posted entry of this journal.\nFirst you should set the journal to allow cancelling entries.'))
if ids:
cr.execute('UPDATE account_move '\
'SET state=%s '\
'WHERE id IN %s', ('draft', tuple(ids),))
return True
- def onchange_line_id(self, cr, uid, ids, line_ids, context=None):
- balance = 0.0
- for line in line_ids:
- if line[2]:
- balance += (line[2]['debit'] or 0.00)- (line[2]['credit'] or 0.00)
- return {'value': {'balance': balance}}
-
def write(self, cr, uid, ids, vals, context=None):
if context is None:
context = {}
if not l[0]:
l[2].update({
'reconcile_id':False,
- 'reconcil_partial_id':False,
+ 'reconcile_partial_id':False,
'analytic_lines':False,
'invoice':False,
'ref':False,
if 'line_id' in vals:
c = context.copy()
c['novalidate'] = True
+ c['period_id'] = vals['period_id'] if 'period_id' in vals else self._get_period(cr, uid, context)
+ c['journal_id'] = vals['journal_id']
+ if 'date' in vals: c['date'] = vals['date']
result = super(account_move, self).create(cr, uid, vals, c)
self.validate(cr, uid, [result], context)
else:
result = super(account_move, self).create(cr, uid, vals, context)
return result
- def copy(self, cr, uid, id, default={}, context=None):
- if context is None:
- context = {}
+ def copy(self, cr, uid, id, default=None, context=None):
+ default = {} if default is None else default.copy()
+ context = {} if context is None else context.copy()
default.update({
'state':'draft',
'name':'/',
obj_move_line = self.pool.get('account.move.line')
for move in self.browse(cr, uid, ids, context=context):
if move['state'] != 'draft':
- raise osv.except_osv(_('UserError'),
- _('You can not delete a posted journal entry "%s"!') % \
+ raise osv.except_osv(_('User Error!'),
+ _('You cannot delete a posted journal entry "%s".') % \
move['name'])
+ for line in move.line_id:
+ if line.invoice:
+ raise osv.except_osv(_('User Error!'),
+ _("Move cannot be deleted if linked to an invoice. (Invoice: %s - Move ID:%s)") % \
+ (line.invoice.number,move.name))
line_ids = map(lambda x: x.id, move.line_id)
context['journal_id'] = move.journal_id.id
context['period_id'] = move.period_id.id
account_id = move.journal_id.default_debit_account_id.id
mode2 = 'debit'
if not account_id:
- raise osv.except_osv(_('UserError'),
- _('There is no default default debit account defined \n' \
- 'on journal "%s"') % move.journal_id.name)
+ raise osv.except_osv(_('User Error!'),
+ _('There is no default debit account defined \n' \
+ 'on journal "%s".') % move.journal_id.name)
else:
account_id = move.journal_id.default_credit_account_id.id
mode2 = 'credit'
if not account_id:
- raise osv.except_osv(_('UserError'),
- _('There is no default default credit account defined \n' \
- 'on journal "%s"') % move.journal_id.name)
+ raise osv.except_osv(_('User Error!'),
+ _('There is no default credit account defined \n' \
+ 'on journal "%s".') % move.journal_id.name)
# find the first line of this move with the current mode
# or create it if it doesn't exist
line_id = self.pool.get('account.move.line').create(cr, uid, {
'name': _(mode.capitalize()+' Centralisation'),
'centralisation': mode,
+ 'partner_id': False,
'account_id': account_id,
'move_id': move.id,
'journal_id': move.journal_id.id,
line_id = self.pool.get('account.move.line').create(cr, uid, {
'name': _('Currency Adjustment'),
'centralisation': 'currency',
+ 'partner_id': False,
'account_id': account_id,
'move_id': move.id,
'journal_id': move.journal_id.id,
if not company_id:
company_id = line.account_id.company_id.id
if not company_id == line.account_id.company_id.id:
- raise osv.except_osv(_('Error'), _("Couldn't create move between different companies"))
+ raise osv.except_osv(_('Error!'), _("Cannot create moves for different companies."))
if line.account_id.currency_id and line.currency_id:
if line.account_id.currency_id.id != line.currency_id.id and (line.account_id.currency_id.id != line.account_id.company_id.currency_id.id):
- raise osv.except_osv(_('Error'), _("""Couldn't create move with currency different from the secondary currency of the account "%s - %s". Clear the secondary currency field of the account definition if you want to accept all currencies.""") % (line.account_id.code, line.account_id.name))
+ raise osv.except_osv(_('Error!'), _("""Cannot create move with currency different from ..""") % (line.account_id.code, line.account_id.name))
if abs(amount) < 10 ** -4:
# If the move is balanced
'line_id': fields.one2many('account.move.line', 'reconcile_id', 'Entry Lines'),
'line_partial_ids': fields.one2many('account.move.line', 'reconcile_partial_id', 'Partial Entry lines'),
'create_date': fields.date('Creation date', readonly=True),
+ 'opening_reconciliation': fields.boolean('Opening Entries Reconciliation', help="Is this reconciliation produced by the opening of a new fiscal year ?."),
}
_defaults = {
'name': lambda self,cr,uid,ctx=None: self.pool.get('ir.sequence').get(cr, uid, 'account.reconcile', context=ctx) or '/',
}
+
+ # You cannot unlink a reconciliation if it is a opening_reconciliation one,
+ # you should use the generate opening entries wizard for that
+ def unlink(self, cr, uid, ids, context=None):
+ for move_rec in self.browse(cr, uid, ids, context=context):
+ if move_rec.opening_reconciliation:
+ raise osv.except_osv(_('Error!'), _('You cannot unreconcile journal items if they has been generated by the \
+ opening/closing fiscal year process.'))
+ return super(account_move_reconcile, self).unlink(cr, uid, ids, context=context)
+
+ # Look in the line_id and line_partial_ids to ensure the partner is the same or empty
+ # on all lines. We allow that only for opening/closing period
+ def _check_same_partner(self, cr, uid, ids, context=None):
+ for reconcile in self.browse(cr, uid, ids, context=context):
+ move_lines = []
+ if not reconcile.opening_reconciliation:
+ if reconcile.line_id:
+ first_partner = reconcile.line_id[0].partner_id.id
+ move_lines = reconcile.line_id
+ elif reconcile.line_partial_ids:
+ first_partner = reconcile.line_partial_ids[0].partner_id.id
+ move_lines = reconcile.line_partial_ids
+ if any([line.partner_id.id != first_partner for line in move_lines]):
+ return False
+ return True
+ _constraints = [
+ (_check_same_partner, 'You can only reconcile journal items with the same partner.', ['line_id']),
+ ]
+
def reconcile_partial_check(self, cr, uid, ids, type='auto', context=None):
total = 0.0
for rec in self.browse(cr, uid, ids, context=context):
'line_ids': fields.one2many('account.move.line', 'tax_code_id', 'Lines'),
'company_id': fields.many2one('res.company', 'Company', required=True),
'sign': fields.float('Coefficent for parent', required=True, help='You can specify here the coefficient that will be used when consolidating the amount of this case into its parent. For example, set 1/-1 if you want to add/substract it.'),
- 'notprintable':fields.boolean("Not Printable in Invoice", help="Check this box if you don't want any VAT related to this Tax Code to appear on invoices"),
+ 'notprintable':fields.boolean("Not Printable in Invoice", help="Check this box if you don't want any tax related to this tax code to appear on invoices"),
'sequence': fields.integer('Sequence', help="Determine the display order in the report 'Accounting \ Reporting \ Generic Reporting \ Taxes \ Taxes Report'"),
}
_check_recursion = check_cycle
_constraints = [
- (_check_recursion, 'Error ! You can not create recursive accounts.', ['parent_id'])
+ (_check_recursion, 'Error!\nYou cannot create recursive accounts.', ['parent_id'])
]
_order = 'code'
PERCENT: tax = price * amount
FIXED: tax = price + amount
NONE: no tax line
- CODE: execute python code. localcontext = {'price_unit':pu, 'address':address_object}
+ CODE: execute python code. localcontext = {'price_unit':pu}
return result in the context
Ex: result=round(price_unit*0.21,4)
"""
def get_precision_tax():
def change_digit_tax(cr):
- res = pooler.get_pool(cr.dbname).get('decimal.precision').precision_get(cr, 1, 'Account')
+ res = pooler.get_pool(cr.dbname).get('decimal.precision').precision_get(cr, SUPERUSER_ID, 'Account')
return (16, res+2)
return change_digit_tax
'applicable_type': fields.selection( [('true','Always'), ('code','Given by Python Code')], 'Applicability', required=True,
help="If not applicable (computed through a Python code), the tax won't appear on the invoice."),
'domain':fields.char('Domain', size=32, help="This field is only used if you develop your own module allowing developers to create specific taxes in a custom domain."),
- 'account_collected_id':fields.many2one('account.account', 'Invoice Tax Account'),
- 'account_paid_id':fields.many2one('account.account', 'Refund Tax Account'),
+ 'account_collected_id':fields.many2one('account.account', 'Invoice Tax Account', help="Set the account that will be set by default on invoice tax lines for invoices. Leave empty to use the expense account."),
+ 'account_paid_id':fields.many2one('account.account', 'Refund Tax Account', help="Set the account that will be set by default on invoice tax lines for refunds. Leave empty to use the expense account."),
+ 'account_analytic_collected_id':fields.many2one('account.analytic.account', 'Invoice Tax Analytic Account', help="Set the analytic account that will be used by default on the invoice tax lines for invoices. Leave empty if you don't want to use an analytic account on the invoice tax lines by default."),
+ 'account_analytic_paid_id':fields.many2one('account.analytic.account', 'Refund Tax Analytic Account', help="Set the analytic account that will be used by default on the invoice tax lines for refunds. Leave empty if you don't want to use an analytic account on the invoice tax lines by default."),
'parent_id':fields.many2one('account.tax', 'Parent Tax Account', select=True),
'child_ids':fields.one2many('account.tax', 'parent_id', 'Child Tax Accounts'),
'child_depend':fields.boolean('Tax on Children', help="Set if the tax computation is based on the computation of child taxes rather than on the total amount."),
'python_applicable':fields.text('Python Code'),
#
- # Fields used for the VAT declaration
+ # Fields used for the Tax declaration
#
- 'base_code_id': fields.many2one('account.tax.code', 'Account Base Code', help="Use this code for the VAT declaration."),
- 'tax_code_id': fields.many2one('account.tax.code', 'Account Tax Code', help="Use this code for the VAT declaration."),
+ 'base_code_id': fields.many2one('account.tax.code', 'Account Base Code', help="Use this code for the tax declaration."),
+ 'tax_code_id': fields.many2one('account.tax.code', 'Account Tax Code', help="Use this code for the tax declaration."),
'base_sign': fields.float('Base Code Sign', help="Usually 1 or -1."),
'tax_sign': fields.float('Tax Code Sign', help="Usually 1 or -1."),
# Same fields for refund invoices
- 'ref_base_code_id': fields.many2one('account.tax.code', 'Refund Base Code', help="Use this code for the VAT declaration."),
- 'ref_tax_code_id': fields.many2one('account.tax.code', 'Refund Tax Code', help="Use this code for the VAT declaration."),
+ 'ref_base_code_id': fields.many2one('account.tax.code', 'Refund Base Code', help="Use this code for the tax declaration."),
+ 'ref_tax_code_id': fields.many2one('account.tax.code', 'Refund Tax Code', help="Use this code for the tax declaration."),
'ref_base_sign': fields.float('Base Code Sign', help="Usually 1 or -1."),
'ref_tax_sign': fields.float('Tax Code Sign', help="Usually 1 or -1."),
'include_base_amount': fields.boolean('Included in base amount', help="Indicates if the amount of tax must be included in the base amount for the computation of the next taxes"),
'company_id': fields.many2one('res.company', 'Company', required=True),
- 'description': fields.char('Tax Code',size=32),
+ 'description': fields.char('Tax Code'),
'price_include': fields.boolean('Tax Included in Price', help="Check this if the price you use on the product and invoices includes this tax."),
'type_tax_use': fields.selection([('sale','Sale'),('purchase','Purchase'),('all','All')], 'Tax Application', required=True)
return self.pool.get('res.company').search(cr, uid, [('parent_id', '=', False)])[0]
_defaults = {
- 'python_compute': '''# price_unit\n# address: res.partner.address object or False\n# product: product.product object or None\n# partner: res.partner object or None\n\nresult = price_unit * 0.10''',
- 'python_compute_inv': '''# price_unit\n# address: res.partner.address object or False\n# product: product.product object or False\n\nresult = price_unit * 0.10''',
+ 'python_compute': '''# price_unit\n# or False\n# product: product.product object or None\n# partner: res.partner object or None\n\nresult = price_unit * 0.10''',
+ 'python_compute_inv': '''# price_unit\n# product: product.product object or False\n\nresult = price_unit * 0.10''',
'applicable_type': 'true',
'type': 'percent',
'amount': 0,
}
_order = 'sequence'
- def _applicable(self, cr, uid, taxes, price_unit, address_id=None, product=None, partner=None):
+ def _applicable(self, cr, uid, taxes, price_unit, product=None, partner=None):
res = []
- obj_partener_address = self.pool.get('res.partner.address')
for tax in taxes:
if tax.applicable_type=='code':
- localdict = {'price_unit':price_unit, 'address':obj_partener_address.browse(cr, uid, address_id), 'product':product, 'partner':partner}
+ localdict = {'price_unit':price_unit, 'product':product, 'partner':partner}
exec tax.python_applicable in localdict
if localdict.get('result', False):
res.append(tax)
res.append(tax)
return res
- def _unit_compute(self, cr, uid, taxes, price_unit, address_id=None, product=None, partner=None, quantity=0):
- taxes = self._applicable(cr, uid, taxes, price_unit, address_id, product, partner)
+ def _unit_compute(self, cr, uid, taxes, price_unit, product=None, partner=None, quantity=0):
+ taxes = self._applicable(cr, uid, taxes, price_unit ,product, partner)
res = []
cur_price_unit=price_unit
- obj_partener_address = self.pool.get('res.partner.address')
for tax in taxes:
# we compute the amount for the current tax object and append it to the result
data = {'id':tax.id,
'name':tax.description and tax.description + " - " + tax.name or tax.name,
'account_collected_id':tax.account_collected_id.id,
'account_paid_id':tax.account_paid_id.id,
+ 'account_analytic_collected_id': tax.account_analytic_collected_id.id,
+ 'account_analytic_paid_id': tax.account_analytic_paid_id.id,
'base_code_id': tax.base_code_id.id,
'ref_base_code_id': tax.ref_base_code_id.id,
'sequence': tax.sequence,
data['tax_amount']=quantity
# data['amount'] = quantity
elif tax.type=='code':
- address = address_id and obj_partener_address.browse(cr, uid, address_id) or None
- localdict = {'price_unit':cur_price_unit, 'address':address, 'product':product, 'partner':partner}
+ localdict = {'price_unit':cur_price_unit, 'product':product, 'partner':partner}
exec tax.python_compute in localdict
amount = localdict['result']
data['amount'] = amount
if tax.child_depend:
latest = res.pop()
amount = amount2
- child_tax = self._unit_compute(cr, uid, tax.child_ids, amount, address_id, product, partner, quantity)
+ child_tax = self._unit_compute(cr, uid, tax.child_ids, amount, product, partner, quantity)
res.extend(child_tax)
if tax.child_depend:
for r in res:
cur_price_unit+=amount2
return res
- def compute_all(self, cr, uid, taxes, price_unit, quantity, address_id=None, product=None, partner=None, force_excluded=False):
+ def compute_all(self, cr, uid, taxes, price_unit, quantity, product=None, partner=None, force_excluded=False):
"""
:param force_excluded: boolean used to say that we don't want to consider the value of field price_include of
tax. It's used in encoding by line where you don't matter if you encoded a tax with that boolean to True or
'taxes': [] # List of taxes, see compute for the format
}
"""
+
+ # By default, for each tax, tax amount will first be computed
+ # and rounded at the 'Account' decimal precision for each
+ # PO/SO/invoice line and then these rounded amounts will be
+ # summed, leading to the total amount for that tax. But, if the
+ # company has tax_calculation_rounding_method = round_globally,
+ # we still follow the same method, but we use a much larger
+ # precision when we round the tax amount for each line (we use
+ # the 'Account' decimal precision + 5), and that way it's like
+ # rounding after the sum of the tax amounts of each line
precision = self.pool.get('decimal.precision').precision_get(cr, uid, 'Account')
- totalin = totalex = round(price_unit * quantity, precision)
+ tax_compute_precision = precision
+ if taxes and taxes[0].company_id.tax_calculation_rounding_method == 'round_globally':
+ tax_compute_precision += 5
+ totalin = totalex = float_round(price_unit * quantity, precision)
tin = []
tex = []
for tax in taxes:
tex.append(tax)
else:
tin.append(tax)
- tin = self.compute_inv(cr, uid, tin, price_unit, quantity, address_id=address_id, product=product, partner=partner)
+ tin = self.compute_inv(cr, uid, tin, price_unit, quantity, product=product, partner=partner, precision=tax_compute_precision)
for r in tin:
totalex -= r.get('amount', 0.0)
totlex_qty = 0.0
totlex_qty = totalex/quantity
except:
pass
- tex = self._compute(cr, uid, tex, totlex_qty, quantity, address_id=address_id, product=product, partner=partner)
+ tex = self._compute(cr, uid, tex, totlex_qty, quantity, product=product, partner=partner, precision=tax_compute_precision)
for r in tex:
totalin += r.get('amount', 0.0)
return {
'taxes': tin + tex
}
- def compute(self, cr, uid, taxes, price_unit, quantity, address_id=None, product=None, partner=None):
- logger = netsvc.Logger()
- logger.notifyChannel("warning", netsvc.LOG_WARNING,
- "Deprecated, use compute_all(...)['taxes'] instead of compute(...) to manage prices with tax included")
- return self._compute(cr, uid, taxes, price_unit, quantity, address_id, product, partner)
+ def compute(self, cr, uid, taxes, price_unit, quantity, product=None, partner=None):
+ _logger.warning("Deprecated, use compute_all(...)['taxes'] instead of compute(...) to manage prices with tax included.")
+ return self._compute(cr, uid, taxes, price_unit, quantity, product, partner)
- def _compute(self, cr, uid, taxes, price_unit, quantity, address_id=None, product=None, partner=None):
+ def _compute(self, cr, uid, taxes, price_unit, quantity, product=None, partner=None, precision=None):
"""
Compute tax values for given PRICE_UNIT, QUANTITY and a buyer/seller ADDRESS_ID.
tax = {'name':'', 'amount':0.0, 'account_collected_id':1, 'account_paid_id':2}
one tax for each tax id in IDS and their children
"""
- res = self._unit_compute(cr, uid, taxes, price_unit, address_id, product, partner, quantity)
+ if not precision:
+ precision = self.pool.get('decimal.precision').precision_get(cr, uid, 'Account')
+ res = self._unit_compute(cr, uid, taxes, price_unit, product, partner, quantity)
total = 0.0
- precision_pool = self.pool.get('decimal.precision')
for r in res:
if r.get('balance',False):
- r['amount'] = round(r.get('balance', 0.0) * quantity, precision_pool.precision_get(cr, uid, 'Account')) - total
+ r['amount'] = round(r.get('balance', 0.0) * quantity, precision) - total
else:
- r['amount'] = round(r.get('amount', 0.0) * quantity, precision_pool.precision_get(cr, uid, 'Account'))
+ r['amount'] = round(r.get('amount', 0.0) * quantity, precision)
total += r['amount']
return res
- def _unit_compute_inv(self, cr, uid, taxes, price_unit, address_id=None, product=None, partner=None):
- taxes = self._applicable(cr, uid, taxes, price_unit, address_id, product, partner)
- obj_partener_address = self.pool.get('res.partner.address')
+ def _unit_compute_inv(self, cr, uid, taxes, price_unit, product=None, partner=None):
+ taxes = self._applicable(cr, uid, taxes, price_unit, product, partner)
res = []
taxes.reverse()
cur_price_unit = price_unit
amount = tax.amount
elif tax.type=='code':
- address = address_id and obj_partener_address.browse(cr, uid, address_id) or None
- localdict = {'price_unit':cur_price_unit, 'address':address, 'product':product, 'partner':partner}
+ localdict = {'price_unit':cur_price_unit, 'product':product, 'partner':partner}
exec tax.python_compute_inv in localdict
amount = localdict['result']
elif tax.type=='balance':
'amount': amount,
'account_collected_id': tax.account_collected_id.id,
'account_paid_id': tax.account_paid_id.id,
+ 'account_analytic_collected_id': tax.account_analytic_collected_id.id,
+ 'account_analytic_paid_id': tax.account_analytic_paid_id.id,
'base_code_id': tax.base_code_id.id,
'ref_base_code_id': tax.ref_base_code_id.id,
'sequence': tax.sequence,
del res[-1]
amount = price_unit
- parent_tax = self._unit_compute_inv(cr, uid, tax.child_ids, amount, address_id, product, partner)
+ parent_tax = self._unit_compute_inv(cr, uid, tax.child_ids, amount, product, partner)
res.extend(parent_tax)
total = 0.0
r['todo'] = 0
return res
- def compute_inv(self, cr, uid, taxes, price_unit, quantity, address_id=None, product=None, partner=None):
+ def compute_inv(self, cr, uid, taxes, price_unit, quantity, product=None, partner=None, precision=None):
"""
Compute tax values for given PRICE_UNIT, QUANTITY and a buyer/seller ADDRESS_ID.
- Price Unit is a VAT included price
+ Price Unit is a Tax included price
RETURN:
[ tax ]
tax = {'name':'', 'amount':0.0, 'account_collected_id':1, 'account_paid_id':2}
one tax for each tax id in IDS and their children
"""
- res = self._unit_compute_inv(cr, uid, taxes, price_unit, address_id, product, partner=None)
+ if not precision:
+ precision = self.pool.get('decimal.precision').precision_get(cr, uid, 'Account')
+ res = self._unit_compute_inv(cr, uid, taxes, price_unit, product, partner=None)
total = 0.0
- obj_precision = self.pool.get('decimal.precision')
for r in res:
- prec = obj_precision.precision_get(cr, uid, 'Account')
if r.get('balance',False):
- r['amount'] = round(r['balance'] * quantity, prec) - total
+ r['amount'] = round(r['balance'] * quantity, precision) - total
else:
- r['amount'] = round(r['amount'] * quantity, prec)
+ r['amount'] = round(r['amount'] * quantity, precision)
total += r['amount']
return res
_defaults = {
'legend': lambda self, cr, uid, context:_('You can specify year, month and date in the name of the model using the following labels:\n\n%(year)s: To Specify Year \n%(month)s: To Specify Month \n%(date)s: Current Date\n\ne.g. My model on %(date)s'),
}
- def generate(self, cr, uid, ids, datas={}, context=None):
+
+ def generate(self, cr, uid, ids, data=None, context=None):
+ if data is None:
+ data = {}
move_ids = []
entry = {}
account_move_obj = self.pool.get('account.move')
if context is None:
context = {}
- if datas.get('date', False):
- context.update({'date': datas['date']})
+ if data.get('date', False):
+ context.update({'date': data['date']})
move_date = context.get('date', time.strftime('%Y-%m-%d'))
move_date = datetime.strptime(move_date,"%Y-%m-%d")
date_maturity = context.get('date',time.strftime('%Y-%m-%d'))
if line.date_maturity == 'partner':
if not line.partner_id:
- raise osv.except_osv(_('Error !'), _("Maturity date of entry line generated by model line '%s' of model '%s' is based on partner payment term!" \
+ raise osv.except_osv(_('Error!'), _("Maturity date of entry line generated by model line '%s' of model '%s' is based on partner payment term!" \
"\nPlease define partner on it!")%(line.name, model.name))
- if line.partner_id.property_payment_term:
+
+ payment_term_id = False
+ if model.journal_id.type in ('purchase', 'purchase_refund') and line.partner_id.property_supplier_payment_term:
+ payment_term_id = line.partner_id.property_supplier_payment_term.id
+ elif line.partner_id.property_payment_term:
payment_term_id = line.partner_id.property_payment_term.id
+ if payment_term_id:
pterm_list = pt_obj.compute(cr, uid, payment_term_id, value=1, date_ref=date_maturity)
if pterm_list:
pterm_list = [l[0] for l in pterm_list]
return move_ids
+ def onchange_journal_id(self, cr, uid, ids, journal_id, context=None):
+ company_id = False
+
+ if journal_id:
+ journal = self.pool.get('account.journal').browse(cr, uid, journal_id, context=context)
+ if journal.company_id.id:
+ company_id = journal.company_id.id
+
+ return {'value': {'company_id': company_id}}
+
account_model()
class account_model_line(osv.osv):
'period_total': fields.integer('Number of Periods', required=True),
'period_nbr': fields.integer('Period', required=True),
'period_type': fields.selection([('day','days'),('month','month'),('year','year')], 'Period Type', required=True),
- 'state': fields.selection([('draft','Draft'),('running','Running'),('done','Done')], 'State', required=True, readonly=True),
+ 'state': fields.selection([('draft','Draft'),('running','Running'),('done','Done')], 'Status', required=True, readonly=True),
'lines_id': fields.one2many('account.subscription.line', 'subscription_id', 'Subscription Lines')
}
_defaults = {
all_moves = []
obj_model = self.pool.get('account.model')
for line in self.browse(cr, uid, ids, context=context):
- datas = {
+ data = {
'date': line.date,
}
- move_ids = obj_model.generate(cr, uid, [line.subscription_id.model_id.id], datas, context)
+ move_ids = obj_model.generate(cr, uid, [line.subscription_id.model_id.id], data, context)
tocheck[line.subscription_id.id] = True
self.write(cr, uid, [line.id], {'move_id':move_ids[0]})
all_moves.extend(move_ids)
'reconcile': fields.boolean('Allow Reconciliation', help="Check this option if you want the user to reconcile entries in this account."),
'shortcut': fields.char('Shortcut', size=12),
'note': fields.text('Note'),
- 'parent_id': fields.many2one('account.account.template', 'Parent Account Template', ondelete='cascade'),
+ 'parent_id': fields.many2one('account.account.template', 'Parent Account Template', ondelete='cascade', domain=[('type','=','view')]),
'child_parent_ids':fields.one2many('account.account.template', 'parent_id', 'Children'),
'tax_ids': fields.many2many('account.tax.template', 'account_account_template_tax_rel', 'account_id', 'tax_id', 'Default Taxes'),
'nocreate': fields.boolean('Optional create', help="If checked, the new chart of accounts will not contain this by default."),
'nocreate': False,
}
- def _check_type(self, cr, uid, ids, context=None):
- if context is None:
- context = {}
- accounts = self.browse(cr, uid, ids, context=context)
- for account in accounts:
- if account.parent_id and account.parent_id.type != 'view':
- return False
- return True
-
_check_recursion = check_cycle
_constraints = [
- (_check_recursion, 'Error ! You can not create recursive account templates.', ['parent_id']),
- (_check_type, 'Configuration Error!\nYou can not define children to an account with internal type different of "View"! ', ['type']),
-
+ (_check_recursion, 'Error!\nYou cannot create recursive account templates.', ['parent_id']),
]
def name_get(self, cr, uid, ids, context=None):
ptids = tmpl_obj.read(cr, uid, [tids[0]['parent_id'][0]], ['code'])
res = None
if not ptids or not ptids[0]['code']:
- raise osv.except_osv(_('Error !'), _('I can not locate a parent code for the template account!'))
+ raise osv.except_osv(_('Error!'), _('There is no parent code for the template account.'))
res = acc_obj.search(cr, uid, [('code','=',ptids[0]['code'])])
return res and res[0] or False
'parent_id': fields.many2one('account.tax.code.template', 'Parent Code', select=True),
'child_ids': fields.one2many('account.tax.code.template', 'parent_id', 'Child Codes'),
'sign': fields.float('Sign For Parent', required=True),
- 'notprintable':fields.boolean("Not Printable in Invoice", help="Check this box if you don't want any VAT related to this Tax Code to appear on invoices"),
+ 'notprintable':fields.boolean("Not Printable in Invoice", help="Check this box if you don't want any tax related to this tax Code to appear on invoices."),
}
_defaults = {
_check_recursion = check_cycle
_constraints = [
- (_check_recursion, 'Error ! You can not create recursive Tax Codes.', ['parent_id'])
+ (_check_recursion, 'Error!\nYou cannot create recursive Tax Codes.', ['parent_id'])
]
_order = 'code,name'
account_tax_code_template()
_columns={
'name': fields.char('Name', size=64, required=True),
'parent_id': fields.many2one('account.chart.template', 'Parent Chart Template'),
- 'code_digits': fields.integer('# of Digits', required=True, help="No. of Digits to use for account code"),
+ 'code_digits': fields.integer('# of Digits', required=True, help="No. of Digits to use for account code"),
'visible': fields.boolean('Can be Visible?', help="Set this to False if you don't want this template to be used actively in the wizard that generate Chart of Accounts from templates, this is useful when you want to generate accounts of this template only when loading its child template."),
'complete_tax_set': fields.boolean('Complete Set of Taxes', help='This boolean helps you to choose if you want to propose to the user to encode the sale and purchase rates or choose from list of taxes. This last choice assumes that the set of tax defined on this template is complete'),
'account_root_id': fields.many2one('account.account.template', 'Root Account', domain=[('parent_id','=',False)]),
'property_account_income_categ': fields.many2one('account.account.template', 'Income Category Account'),
'property_account_expense': fields.many2one('account.account.template', 'Expense Account on Product Template'),
'property_account_income': fields.many2one('account.account.template', 'Income Account on Product Template'),
- 'property_reserve_and_surplus_account': fields.many2one('account.account.template', 'Reserve and Profit/Loss Account', domain=[('type', '=', 'payable')], help='This Account is used for transferring Profit/Loss(If It is Profit: Amount will be added, Loss: Amount will be deducted.), Which is calculated from Profilt & Loss Report'),
'property_account_income_opening': fields.many2one('account.account.template', 'Opening Entries Income Account'),
'property_account_expense_opening': fields.many2one('account.account.template', 'Opening Entries Expense Account'),
}
'python_applicable':fields.text('Python Code'),
#
- # Fields used for the VAT declaration
+ # Fields used for the Tax declaration
#
- 'base_code_id': fields.many2one('account.tax.code.template', 'Base Code', help="Use this code for the VAT declaration."),
- 'tax_code_id': fields.many2one('account.tax.code.template', 'Tax Code', help="Use this code for the VAT declaration."),
+ 'base_code_id': fields.many2one('account.tax.code.template', 'Base Code', help="Use this code for the tax declaration."),
+ 'tax_code_id': fields.many2one('account.tax.code.template', 'Tax Code', help="Use this code for the tax declaration."),
'base_sign': fields.float('Base Code Sign', help="Usually 1 or -1."),
'tax_sign': fields.float('Tax Code Sign', help="Usually 1 or -1."),
# Same fields for refund invoices
- 'ref_base_code_id': fields.many2one('account.tax.code.template', 'Refund Base Code', help="Use this code for the VAT declaration."),
- 'ref_tax_code_id': fields.many2one('account.tax.code.template', 'Refund Tax Code', help="Use this code for the VAT declaration."),
+ 'ref_base_code_id': fields.many2one('account.tax.code.template', 'Refund Base Code', help="Use this code for the tax declaration."),
+ 'ref_tax_code_id': fields.many2one('account.tax.code.template', 'Refund Tax Code', help="Use this code for the tax declaration."),
'ref_base_sign': fields.float('Base Code Sign', help="Usually 1 or -1."),
'ref_tax_sign': fields.float('Tax Code Sign', help="Usually 1 or -1."),
'include_base_amount': fields.boolean('Include in Base Amount', help="Set if the amount of tax must be included in the base amount before computing the next taxes."),
- 'description': fields.char('Internal Name', size=32),
+ 'description': fields.char('Internal Name'),
'type_tax_use': fields.selection([('sale','Sale'),('purchase','Purchase'),('all','All')], 'Tax Use In', required=True,),
'price_include': fields.boolean('Tax Included in Price', help="Check this if the price you use on the product and invoices includes this tax."),
}
return self.pool.get('res.company').search(cr, uid, [('parent_id', '=', False)])[0]
_defaults = {
- 'python_compute': lambda *a: '''# price_unit\n# address: res.partner.address object or False\n# product: product.product object or None\n# partner: res.partner object or None\n\nresult = price_unit * 0.10''',
- 'python_compute_inv': lambda *a: '''# price_unit\n# address: res.partner.address object or False\n# product: product.product object or False\n\nresult = price_unit * 0.10''',
+ 'python_compute': lambda *a: '''# price_unit\n# product: product.product object or None\n# partner: res.partner object or None\n\nresult = price_unit * 0.10''',
+ 'python_compute_inv': lambda *a: '''# price_unit\n# product: product.product object or False\n\nresult = price_unit * 0.10''',
'applicable_type': 'true',
'type': 'percent',
'amount': 0,
_columns = {
'company_id':fields.many2one('res.company', 'Company', required=True),
+ 'currency_id': fields.many2one('res.currency', 'Currency', help="Currency as per company's country."),
+ 'only_one_chart_template': fields.boolean('Only One Chart Template Available'),
'chart_template_id': fields.many2one('account.chart.template', 'Chart Template', required=True),
'bank_accounts_id': fields.one2many('account.bank.accounts.wizard', 'bank_account_id', 'Cash and Banks', required=True),
'code_digits':fields.integer('# of Digits', required=True, help="No. of Digits to use for account code"),
- 'seq_journal':fields.boolean('Separated Journal Sequences', help="Check this box if you want to use a different sequence for each created journal. Otherwise, all will use the same sequence."),
"sale_tax": fields.many2one("account.tax.template", "Default Sale Tax"),
"purchase_tax": fields.many2one("account.tax.template", "Default Purchase Tax"),
'sale_tax_rate': fields.float('Sales Tax(%)'),
'purchase_tax_rate': fields.float('Purchase Tax(%)'),
'complete_tax_set': fields.boolean('Complete Set of Taxes', help='This boolean helps you to choose if you want to propose to the user to encode the sales and purchase rates or use the usual m2o fields. This last choice assumes that the set of tax defined for the chosen template is complete'),
}
+
+ def onchange_company_id(self, cr, uid, ids, company_id, context=None):
+ currency_id = False
+ if company_id:
+ currency_id = self.pool.get('res.company').browse(cr, uid, company_id, context=context).currency_id.id
+ return {'value': {'currency_id': currency_id}}
+
def onchange_tax_rate(self, cr, uid, ids, rate=False, context=None):
return {'value': {'purchase_tax_rate': rate or False}}
return res
def default_get(self, cr, uid, fields, context=None):
- res = super(wizard_multi_charts_accounts, self).default_get(cr, uid, fields, context=context)
+ res = super(wizard_multi_charts_accounts, self).default_get(cr, uid, fields, context=context)
tax_templ_obj = self.pool.get('account.tax.template')
if 'bank_accounts_id' in fields:
res.update({'bank_accounts_id': [{'acc_name': _('Cash'), 'account_type': 'cash'},{'acc_name': _('Bank'), 'account_type': 'bank'}]})
if 'company_id' in fields:
res.update({'company_id': self.pool.get('res.users').browse(cr, uid, [uid], context=context)[0].company_id.id})
- if 'seq_journal' in fields:
- res.update({'seq_journal': True})
+ if 'currency_id' in fields:
+ company_id = res.get('company_id') or False
+ if company_id:
+ company_obj = self.pool.get('res.company')
+ country_id = company_obj.browse(cr, uid, company_id, context=context).country_id.id
+ currency_id = company_obj.on_change_country(cr, uid, company_id, country_id, context=context)['value']['currency_id']
+ res.update({'currency_id': currency_id})
ids = self.pool.get('account.chart.template').search(cr, uid, [('visible', '=', True)], context=context)
if ids:
if 'chart_template_id' in fields:
- res.update({'chart_template_id': ids[0]})
+ res.update({'only_one_chart_template': len(ids) == 1, 'chart_template_id': ids[0]})
if 'sale_tax' in fields:
sale_tax_ids = tax_templ_obj.search(cr, uid, [("chart_template_id"
, "=", ids[0]), ('type_tax_use', 'in', ('sale','all'))], order="sequence")
return res
def fields_view_get(self, cr, uid, view_id=None, view_type='form', context=None, toolbar=False, submenu=False):
+ if context is None:context = {}
res = super(wizard_multi_charts_accounts, self).fields_view_get(cr, uid, view_id=view_id, view_type=view_type, context=context, toolbar=toolbar,submenu=False)
cmp_select = []
acc_template_obj = self.pool.get('account.chart.template')
# Get the analytic journal
data = False
if journal_type in ('sale', 'sale_refund'):
- data = obj_data.get_object_reference(cr, uid, 'account', 'analytic_journal_sale')
+ data = obj_data.get_object_reference(cr, uid, 'account', 'analytic_journal_sale')
elif journal_type in ('purchase', 'purchase_refund'):
pass
elif journal_type == 'general':
default_account = acc_template_ref.get(template.property_account_income_opening.id)
return default_account
- def _get_view_id(journal_type):
- # Get the journal views
- if journal_type in ('general', 'situation'):
- data = obj_data.get_object_reference(cr, uid, 'account', 'account_journal_view')
- elif journal_type in ('sale_refund', 'purchase_refund'):
- data = obj_data.get_object_reference(cr, uid, 'account', 'account_sp_refund_journal_view')
- else:
- data = obj_data.get_object_reference(cr, uid, 'account', 'account_sp_journal_view')
- return data and data[1] or False
-
journal_names = {
'sale': _('Sales Journal'),
'purchase': _('Purchase Journal'),
'code': journal_codes[journal_type],
'company_id': company_id,
'centralisation': journal_type == 'situation',
- 'view_id': _get_view_id(journal_type),
'analytic_journal_id': _get_analytic_journal(journal_type),
'default_credit_account_id': _get_default_account(journal_type, 'credit'),
'default_debit_account_id': _get_default_account(journal_type, 'debit'),
('property_account_income_categ','product.category','account.account'),
('property_account_expense','product.template','account.account'),
('property_account_income','product.template','account.account'),
- ('property_reserve_and_surplus_account','res.company','account.account')
]
template = self.pool.get('account.chart.template').browse(cr, uid, chart_template_id, context=context)
for record in todo_list:
property_obj.create(cr, uid, vals, context=context)
return True
- def _install_template(self, cr, uid, template_id, company_id, code_digits=None, obj_wizard=None, acc_ref={}, taxes_ref={}, tax_code_ref={}, context=None):
+ def _install_template(self, cr, uid, template_id, company_id, code_digits=None, obj_wizard=None, acc_ref=None, taxes_ref=None, tax_code_ref=None, context=None):
'''
This function recursively loads the template objects and create the real objects from them.
* a last identical containing the mapping of tax code templates and tax codes
:rtype: tuple(dict, dict, dict)
'''
+ if acc_ref is None:
+ acc_ref = {}
+ if taxes_ref is None:
+ taxes_ref = {}
+ if tax_code_ref is None:
+ tax_code_ref = {}
template = self.pool.get('account.chart.template').browse(cr, uid, template_id, context=context)
if template.parent_id:
tmp1, tmp2, tmp3 = self._install_template(cr, uid, template.parent_id.id, company_id, code_digits=code_digits, acc_ref=acc_ref, taxes_ref=taxes_ref, tax_code_ref=tax_code_ref, context=context)
tax_code_ref.update(tmp3)
return acc_ref, taxes_ref, tax_code_ref
- def _load_template(self, cr, uid, template_id, company_id, code_digits=None, obj_wizard=None, account_ref={}, taxes_ref={}, tax_code_ref={}, context=None):
+ def _load_template(self, cr, uid, template_id, company_id, code_digits=None, obj_wizard=None, account_ref=None, taxes_ref=None, tax_code_ref=None, context=None):
'''
This function generates all the objects from the templates
* a last identical containing the mapping of tax code templates and tax codes
:rtype: tuple(dict, dict, dict)
'''
+ if account_ref is None:
+ account_ref = {}
+ if taxes_ref is None:
+ taxes_ref = {}
+ if tax_code_ref is None:
+ tax_code_ref = {}
template = self.pool.get('account.chart.template').browse(cr, uid, template_id, context=context)
obj_tax_code_template = self.pool.get('account.tax.code.template')
obj_acc_tax = self.pool.get('account.tax')
all the provided information to create the accounts, the banks, the journals, the taxes, the tax codes, the
accounting properties... accordingly for the chosen company.
'''
+ obj_data = self.pool.get('ir.model.data')
ir_values_obj = self.pool.get('ir.values')
obj_wizard = self.browse(cr, uid, ids[0])
company_id = obj_wizard.company_id.id
+
+ self.pool.get('res.company').write(cr, uid, [company_id], {'currency_id': obj_wizard.currency_id.id})
+
+ # When we install the CoA of first company, set the currency to price types and pricelists
+ if company_id==1:
+ for ref in (('product','list_price'),('product','standard_price'),('product','list0'),('purchase','list0')):
+ try:
+ tmp2 = obj_data.get_object_reference(cr, uid, *ref)
+ if tmp2:
+ self.pool.get(tmp2[0]).write(cr, uid, tmp2[1], {
+ 'currency_id': obj_wizard.currency_id.id
+ })
+ except ValueError, e:
+ pass
+
# If the floats for sale/purchase rates have been filled, create templates from them
self._create_tax_templates_from_rates(cr, uid, obj_wizard, company_id, context=context)
# Install all the templates objects and generate the real objects
acc_template_ref, taxes_ref, tax_code_ref = self._install_template(cr, uid, obj_wizard.chart_template_id.id, company_id, code_digits=obj_wizard.code_digits, obj_wizard=obj_wizard, context=context)
- # write values of default taxes for product
+ # write values of default taxes for product as super user
if obj_wizard.sale_tax and taxes_ref:
- ir_values_obj.set(cr, 1, key='default', key2=False, name="taxes_id", company=company_id,
- models =[('product.product',False)], value=[taxes_ref[obj_wizard.sale_tax.id]])
+ ir_values_obj.set_default(cr, SUPERUSER_ID, 'product.product', "taxes_id", [taxes_ref[obj_wizard.sale_tax.id]], for_all_users=True, company_id=company_id)
if obj_wizard.purchase_tax and taxes_ref:
- ir_values_obj.set(cr, 1, key='default', key2=False, name="supplier_taxes_id", company=company_id,
- models =[('product.product',False)], value=[taxes_ref[obj_wizard.purchase_tax.id]])
+ ir_values_obj.set_default(cr, SUPERUSER_ID, 'product.product', "supplier_taxes_id", [taxes_ref[obj_wizard.purchase_tax.id]], for_all_users=True, company_id=company_id)
# Create Bank journals
self._create_bank_journals_from_o2m(cr, uid, obj_wizard, company_id, acc_template_ref, context=context)
- action = {
- 'type': 'ir.actions.act_window',
- 'view_type': 'form',
- 'view_mode': 'form',
- 'res_model': 'board.board',
- 'view_id': self.pool.get('ir.model.data').get_object_reference(cr, uid, 'account', 'board_account_form')[1],
- 'menu_id': self.pool.get('ir.model.data').get_object_reference(cr, uid, 'account', 'menu_finance')[1]
- }
- return action
+ return {}
def _prepare_bank_journal(self, cr, uid, line, current_num, default_account_id, company_id, context=None):
'''
- This function prepares the value to use for the creation of a bank journal created through the wizard of
+ This function prepares the value to use for the creation of a bank journal created through the wizard of
generating COA from templates.
:param line: dictionary containing the values encoded by the user related to his bank account
'''
obj_data = self.pool.get('ir.model.data')
obj_journal = self.pool.get('account.journal')
- # Get the id of journal views
- tmp = obj_data.get_object_reference(cr, uid, 'account', 'account_journal_bank_view_multi')
- view_id_cur = tmp and tmp[1] or False
- tmp = obj_data.get_object_reference(cr, uid, 'account', 'account_journal_bank_view')
- view_id_cash = tmp and tmp[1] or False
+
- # we need to loop again to find next number for journal code
+ # we need to loop again to find next number for journal code
# because we can't rely on the value current_num as,
- # its possible that we already have bank journals created (e.g. by the creation of res.partner.bank)
+ # its possible that we already have bank journals created (e.g. by the creation of res.partner.bank)
# and the next number for account code might have been already used before for journal
for num in xrange(current_num, 100):
# journal_code has a maximal size of 5, hence we can enforce the boundary num < 100
if not ids:
break
else:
- raise osv.except_osv(_('Error'), _('Cannot generate an unused journal code.'))
+ raise osv.except_osv(_('Error!'), _('Cannot generate an unused journal code.'))
vals = {
'name': line['acc_name'],
'default_debit_account_id': default_account_id,
}
if line['currency_id']:
- vals['view_id'] = view_id_cur
vals['currency'] = line['currency_id']
- else:
- vals['view_id'] = view_id_cash
+
return vals
def _prepare_bank_account(self, cr, uid, line, new_code, acc_template_ref, ref_acc_bank, company_id, context=None):
journal_data.append(vals)
ref_acc_bank = obj_wizard.chart_template_id.bank_account_view_id
if journal_data and not ref_acc_bank.code:
- raise osv.except_osv(_('Configuration Error !'), _('The bank account defined on the selected chart of accounts hasn\'t a code.'))
+ raise osv.except_osv(_('Configuration Error!'), _('You have to set a code for the bank account defined on the selected chart of accounts.'))
current_num = 1
for line in journal_data:
_columns = {
'acc_name': fields.char('Account Name.', size=64, required=True),
- 'bank_account_id': fields.many2one('wizard.multi.charts.accounts', 'Bank Account', required=True),
+ 'bank_account_id': fields.many2one('wizard.multi.charts.accounts', 'Bank Account', required=True, ondelete='cascade'),
'currency_id': fields.many2one('res.currency', 'Secondary Currency', help="Forces all moves for this account to have this secondary currency."),
'account_type': fields.selection([('cash','Cash'), ('check','Check'), ('bank','Bank')], 'Account Type', size=32),
}
projects / odoo / odoo.git / blobdiff