~openerp-commiter/openobject-addons/trunk-extra-addons

# -*- encoding: utf-8 -*-

##############################################################################

#

# Copyright (c) 2008 Sandas. (http://www.sandas.eu) All Rights Reserved.

#

# WARNING: This program as such is intended to be used by professional

# programmers who take the whole responsability of assessing all potential

# consequences resulting from its eventual inadequacies and bugs

# End users who are looking for a ready-to-use solution with commercial

# garantees and support are strongly adviced to contract a Free Software

# Service Company

#

# This program is Free Software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; either version 2

# of the License, or (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

#

##############################################################################

import time

from osv import fields, osv

from base import base_delete_unit_test_records, base_get_default_currency

from decimal import Decimal

class personal_account_entry(osv.osv):

	_name = "personal.base.account.entry"

	_description = "Account Entry"

	_order = "date DESC"

	def _get_accounts_fnc(self, cr, uid, ids, prop, unknow_none, unknow_dict):

		res = {}

		for id in ids:

			res[id] = []

			for entry in self.browse(cr, uid, [id]):

				for line in entry.line_ids:

					res[id].append([line.account_id.id])

		return res

	_columns = {

		'user_id': fields.many2one('res.users', 'User', required=True),

		'date': fields.date('Date', required=True, select=True, states={'confirmed':[('readonly',True)]}),

		'name': fields.char('Description', size=64, required=True, select=True, states={'confirmed':[('readonly',True)]}),

		'line_ids': fields.one2many('personal.base.account.entry.line', 'parent_id', 'Entries', states={'confirmed':[('readonly',True)]}),

		'currency_id': fields.many2one('res.currency', 'Currency', states={'confirmed':[('readonly',True)]}),

		'note': fields.text('Note'),

		'state': fields.selection([('draft', 'Draft'),('confirmed', 'Confirmed')], 'State', required=True, readonly=True),

		'created_in_model_id': fields.many2one('ir.model', 'Created in Model', required=True, readonly=True),

		#fields for unit_test

        'unit_test': fields.boolean(string='unit_test'),

	}

	_defaults = {

		'user_id': lambda self, cr, uid, context: uid,

		'date': lambda *a: time.strftime('%Y-%m-%d'),

		'currency_id': lambda self, cr, uid, context: base_get_default_currency(cr, uid, context),

		'created_in_model_id': lambda self, cr, uid, context: self.pool.get('ir.model').search(cr, uid, [('model','=',self._name)])[0],

		'state': lambda *a: 'draft',

		'unit_test': lambda *a: False,

	}

	#def test_create(self, cr, uid, vals, context={}):

	#	id = self.create(cr, user, vals, context=context)

	#	print "entry_create", vals

	#	print "entry_create", id

	def search(self, cr, uid, args, offset=0, limit=2000, order=None, context=None, count=False):

		args.append(('user_id','=',uid))

		for arg in args:

			if arg[0] == 'created_in_model_id':

				try:

					int(arg[2])

					created_in_model_is_string = False

				except:

					created_in_model_is_string = True

				if created_in_model_is_string:

					model_ids =	self.pool.get('ir.model').search(cr, uid,

																 [('model','=',arg[2])])

					if model_ids == []:

						raise osv.except_osv('Error', 'Unknown model %s!' % arg[2])

					arg = (arg[0], arg[1], model_ids[0])

				break

		return osv.orm.orm.search(self, cr, uid, args, offset, limit, order,

								  context=context)

	def unlink(self, cr, uid, ids, context={}, check=True):

		for entry in self.browse(cr, uid, ids, context):

			if entry.state <> 'draft':

				raise osv.except_osv('Error',

						'You can not delete confirmed entry: "%s"!' % entry.name)

			for line in entry.line_ids:

				line.unlink(cr, uid, [line.id])

		return super(personal_account_entry, self).unlink(cr, uid, ids, context)

	def confirm(self, cr, uid, ids, *args):

		rec_lines = self.pool.get('personal.base.account.entry.line')

		rec_currency = self.pool.get('res.currency')

		for entry in self.browse(cr, uid, ids):

			if entry.user_id.id != uid:

				raise osv.except_osv('Error', 'Wrong user!')

			if entry.state != 'draft':

				raise osv.except_osv('Error', 'Only Draft entries can be confirmed!')

			amount = Decimal(0)

			_debit_amount = Decimal(0)

			_credit_amount = Decimal(0)

			currency = None

			for line in entry.line_ids:

				if line.state != 'draft':

					raise osv.except_osv('Error', 'Only Draft entries can be confirmed!')

				if line.date != entry.date:

					rec_lines.write(cr, uid, [line.id], {'date': entry.date})

				if not currency:

					currency = line.currency_id

				if line.debit_amount != 0:

					line_amount = line.debit_amount

				else:

					line_amount =  -line.credit_amount

				_debit_amount += Decimal(str(rec_currency.compute_with_currency_rate(cr, uid, line.currency_id.rate, currency.id, line.debit_amount)))

				_credit_amount += Decimal(str(rec_currency.compute_with_currency_rate(cr, uid, line.currency_id.rate, currency.id, line.credit_amount)))

				amount += Decimal(str(rec_currency.compute_with_currency_rate(cr, uid, line.currency_id.rate, currency.id, line_amount)))

			if amount != 0:

				raise osv.except_osv('Error', 'Sum of all lines amounts must be zero! You have %s in debit and %s in credit.' % (str(_debit_amount), str(_credit_amount)))

		for entry in self.browse(cr, uid, ids):

			for line in entry.line_ids:

				if line.state=='draft':

					self.pool.get('personal.base.account.entry.line').write(cr, uid, [line.id], {'state':'confirmed'})

		self.write(cr, uid, ids, {'state':'confirmed'})

		return True

	def return_entry(self, cr, uid, ids, *args):

		self.write(cr, uid, ids, {'state':'draft'})

		for entry in self.browse(cr, uid, ids):

			for line in entry.line_ids:

				if line.state=='confirmed':

					self.pool.get('personal.base.account.entry.line').write(cr, uid, [line.id], {'state':'draft'})

		return True

	#for unit tests

	def delete_unit_test_records(self, cr, uid):

		user_rec = self.pool.get('res.users')

		for user in user_rec.search(cr, uid, [('unit_test','=',True)]):

			ids = self.search(cr, user, [('unit_test','=',True)])

			self.return_entry(cr, user, ids)

		base_delete_unit_test_records(self, cr, uid)

	def test_if_confirm_possible(self, cr, uid, ids):

		try:

			self.confirm(cr, uid, ids)

		except:

			return

		assert False, "Entries confirmation checked out not everything."

personal_account_entry()

class personal_account_entry_line(osv.osv):

	_name = "personal.base.account.entry.line"

	_description = "Account Entry Line"

	_order = "date, id"

	def _get_balance_fnc(self, cr, uid, ids, prop, unknow_none, unknow_dict):

		res = {}

		for id in ids:

			line = self.browse(cr, uid, id)

			res[id] = 0.0

			for search_line_id in self.search(cr, uid, 

					[('account_id', '=', line.account_id.id),

					 ('date', '<=', line.date),

					 ('state', '=', 'confirmed')]

			):

				sum_line = self.browse(cr, uid, search_line_id)

				if (sum_line.date < line.date) or (search_line_id <= line.id):

					res[id] = res[id] + (sum_line.amount_base * line.account_id.type_id.sign)

#            for child_id in self.read(cr, uid, [id], ['child_ids'])[0]['child_ids']:

#                for child in self.browse(cr, uid, [child_id]):

#                    res[child_id] = child.balance

#                    res[id] = res[id] + res[child_id]

		return res

	def _get_amount_base_with_sign(self, cr, uid, ids, prop, unknow_none, context):

		res = {}

		for id in ids:

			line = self.browse(cr, uid, id)

			res[id] = line.amount_base * line.account_id.type_id.sign

		return res

	def _get_default_date(self, cr, uid, context):

		if 'date' in context:

			return context['date']

		else:

			return time.strftime('%Y-%m-%d')

	def _get_default_currency(self, cr, uid, context):

		if 'currency_id' in context:

			return context['currency_id']

		else:

			return 0

	def _check_amounts(self, cr, uid, ids):

		currency_obj = self.pool.get('res.currency')

		lines = self.browse(cr, uid, ids)

		for l in lines:

			if (l.debit_amount != 0) and (l.credit_amount != 0):

				return False

			currency_rate = currency_obj.personal_calc_currency_rate(cr, uid, l.account_id.id, l.currency_id.id)

			if (l.debit_amount != 0):

				local_amount_base = self._calc_amount_base(cr, uid, l.account_id.id, currency_rate, l.debit_amount)

			else:

				local_amount_base = self._calc_amount_base(cr, uid, l.account_id.id, currency_rate, -l.credit_amount)

			hasChanges = False

			if (currency_obj.round(cr, uid, l.currency_id, l.amount_base) != currency_obj.round(cr, uid, l.currency_id, local_amount_base)):

				self.write(cr, uid, [l['id']], {'amount_base': local_amount_base})

		return True

	_columns = {

		'user_id': fields.many2one('res.users', 'User', required=True),

	    'date': fields.date('Date', required=True, states={'confirmed':[('readonly',True)]}),

		'parent_id': fields.many2one('personal.base.account.entry', 'Entry', required=True, states={'confirmed':[('readonly',True)]}),

		'name': fields.char('Description', size=64, select=True, states={'confirmed':[('readonly',True)]}),

		'account_id': fields.many2one('personal.base.account', 'Account', required=True, select=True, states={'confirmed':[('readonly',True)]}),

		'currency_id': fields.many2one('res.currency', 'Currency', required=True, states={'confirmed':[('readonly',True)]}),

		'currency_rate': fields.float('Currency Rate', digits=(12,6), required=True, states={'confirmed':[('readonly',True)]}),

		'debit_amount': fields.float('Debit Amount', digits=(10,2), states={'confirmed':[('readonly',True)]}),

		'credit_amount': fields.float('Credit Amount', digits=(10,2), states={'confirmed':[('readonly',True)]}),

		#'amount': fields.float('Amount', digits=(10,2)),

		'amount_base': fields.float('Amount Base', digits=(10,2), states={'confirmed':[('readonly',True)]}),

		'state': fields.selection([('draft', 'Draft'),('confirmed', 'Confirmed')], 'State', required=True, readonly=True),

		'balance': fields.function(_get_balance_fnc, method=True, type="float", digits=(10,2), string='Balance'),

		'amount_base_with_sign': fields.function(_get_amount_base_with_sign, method=True, type="float", digits=(10,2), string='Amount'),

		#fields for unit_test

        'unit_test': fields.boolean(string='unit_test')

	}

	_defaults = {

		'user_id': lambda self, cr, uid, context: uid,

		'date': lambda self, cr, uid, context: \

				self._get_default_date(cr, uid, context=context),

		'currency_id': lambda self, cr, uid, context: \

				self._get_default_currency(cr, uid, context=context),

		'currency_rate': lambda *a: 1,

		'state': lambda *a: 'draft',

		'unit_test': lambda *a: False,

	}

	_constraints = [

        (_check_amounts, 'Error: You must enter only one amount.', ['debit_amount', 'credit_amount'])

    ]	

	_fields_from_parent = ['date', 'currency_id']

	def create(self, cr, uid, vals, context={}):

		#without this don't work 'parent_id' in unit tests

		if ("unit_test" in vals) and (vals["unit_test"]):	

			cr.commit()

		entry_rec = self.pool.get('personal.base.account.entry')

		parent = entry_rec.read(cr, uid, [vals['parent_id']], self._fields_from_parent)

		for field in self._fields_from_parent:

			if not (field in context): 

				if parent[0][field]:

					if ('_id' in field):

						field_value = parent[0][field][0]

					else:

						field_value = parent[0][field]

				if not (field in vals):

					context[field] = field_value

				else:

					context[field] = field_value

		#needed for unit test, because <record> tag haven't uid attribute

		user = uid

		if ('user_id' in vals) and (vals['user_id'] != user):

			user = vals['user_id']

		if ("account_id" in vals):

			acc_rec = self.pool.get('personal.base.account')

			if acc_rec.read(cr, user, [vals["account_id"]], ['user_id'])[0]['user_id'][0] != user:

				raise osv.except_osv('Error', 'Wrong account!')

		if ("parent_id" in vals):

			if entry_rec.read(cr, user, [vals["parent_id"]], ['user_id'])[0]['user_id'][0] != user:

				raise osv.except_osv('Error', 'Wrong entry line parent!')

		return super(personal_account_entry_line, self).create(cr, user, vals, context=context)

	def search(self, cr, uid, args, offset=0, limit=2000, order=None, context=None, count=False):

		args.append(('user_id','=',uid))

		if context:

			if 'filter_by_active_id' in context:

				args.append(('parent_id','=',

					self.read(cr, uid, [context['filter_by_active_id']], ['parent_id'])['parent_id'][0]))

		return osv.orm.orm.search(self, cr, uid, args, offset, limit, order,

								  context=context)

	def confirm(self, cr, uid, ids):

		for line in self.browse(cr, uid, ids):

			if ((line.debit_amount == 0) and (line.credit_amount == 0)) or (line.amount_base == 0):

				raise osv.except_osv('Error', 'Not found line amount!')

		self.write(cr, uid, ids, {'state':'confirmed'})

	def unlink(self, cr, uid, ids, context={}, check=True):

		for line in self.browse(cr, uid, ids, context):

			if line.state <> 'draft':

				raise osv.except_osv('Error', 'You can not delete confirmed entry: "%s"!' % (line.name or ''))

		return super(personal_account_entry_line, self).unlink(cr, uid, ids, context)

	def return_entry(self, cr, uid, ids):

		self.write(cr, uid, ids, {'state':'draft'})

	def _calc_amount_base(self, cr, uid, account_id, currency_rate, amount):

		if not account_id:

			return amount

		acc_pool = self.pool.get('personal.base.account')

		currency_pool = self.pool.get('res.currency')

		account = acc_pool.browse(cr, uid, account_id)

		to_currency = account.currency_id.id

		if currency_rate != 1:

			return currency_pool.compute_with_currency_rate(cr, uid, currency_rate, to_currency, amount)

		else:

			return amount

		#line_rec = self.pool.get('personal.base.account.entry.line')

		#acc_rec = self.pool.get('personal.base.account')

		#currency_rec = self.pool.get('res.currency')

		#for id in ids:

		#	curr_line = self.read(cr, uid, [id], ["amount", "account_id", "currency_id"])[0]

		#	curr_acc = acc_rec.read(cr, uid, [curr_line["account_id"][0]], ["currency_id"])[0]

		#	from_currency = curr_line["currency_id"][0]

		#	to_currency = curr_acc["currency_id"][0]

		#	if from_currency != to_currency:

		#		self.write(cr, uid, id, 

		#			{'amount_base': currency_rec.compute(cr, uid, from_currency, to_currency, curr_line["amount"])})

		#	else:

		#		self.write(cr, uid, id, 

		#			{'amount_base': currency_rec.compute(cr, uid, from_currency, to_currency, curr_line["amount"])})

	def onchange_base(self, cr, uid, ids, state):

		if state == 'confirmed':

			raise osv.except_osv('Error', 'It is not allowed to edit confirmed entries!')

		return {'value':{}}

	def onchange_debit_amount(self, cr, uid, ids, account_id, currency_id, currency_rate, debit_amount, credit_amount, state):

		debit_amount -= credit_amount

		credit_amount = 0

		return self.onchange_amount(cr, uid, ids, account_id, currency_id, currency_rate, debit_amount, credit_amount, state)

	def onchange_credit_amount(self, cr, uid, ids, account_id, currency_id, currency_rate, debit_amount, credit_amount, state):

		credit_amount += debit_amount

		debit_amount = 0

		return self.onchange_amount(cr, uid, ids, account_id, currency_id, currency_rate, debit_amount, credit_amount, state)

	#This is allways the last onchange function

	def onchange_amount(self, cr, uid, ids, account_id, currency_id, currency_rate, debit_amount, credit_amount, state):

		self.onchange_base(cr, uid, ids, state)

		v = {'value':{}}

		if debit_amount>0:

			_amount = debit_amount

		else:

			_amount = -credit_amount

		v['value']['currency_id'] = currency_id

		v['value']['currency_rate'] = currency_rate

		v['value']['credit_amount'] = credit_amount

		v['value']['debit_amount'] = debit_amount

		v['value']['amount_base'] = self._calc_amount_base(cr, uid, account_id, currency_rate, _amount)

		return v

	def onchange_currency_id(self, cr, uid, ids, account_id, currency_id, currency_rate, debit_amount, credit_amount, state):

		self.onchange_base(cr, uid, ids, state)

		currency_pool = self.pool.get('res.currency')

		currency_rate = currency_pool.personal_calc_currency_rate(cr, uid, account_id, currency_id)

		return self.onchange_amount(cr, uid, ids, account_id, currency_id, currency_rate, debit_amount, credit_amount, state)

	def onchange_account_id(self, cr, uid, ids, account_id, currency_id, currency_rate, debit_amount, credit_amount, state):

		self.onchange_base(cr, uid, ids, state)

		#v = {'value':{}}

		if (account_id and (not currency_id or not currency_rate)):

			acc_pool = self.pool.get('personal.base.account')

			account = acc_pool.browse(cr, uid, account_id)

			currency_id = account.currency_id.id

		return self.onchange_currency_id(cr, uid, ids, account_id, currency_id, currency_rate, debit_amount, credit_amount, state)

	def onchange_amount_base(self, cr, uid, ids, account_id, currency_id, currency_rate, amount_base, state):

		self.onchange_base(cr, uid, ids, state)

		currency_pool = self.pool.get('res.currency')

		currency_rate = currency_pool.personal_calc_currency_rate(cr, uid, account_id, currency_id)

		debit_amount = 0

		credit_amount = 0

		if currency_rate != 0:

			if amount_base > 0:

				debit_amount = amount_base / currency_rate

			else:

				credit_amount = (-amount_base) / currency_rate

		else:

			amount_base = 0

		return self.onchange_amount(cr, uid, ids, account_id, currency_id, currency_rate, debit_amount, credit_amount, state)

	#for unit tests

	def delete_unit_test_records(self, cr, uid):

		base_delete_unit_test_records(self, cr, uid)

	def test_if_create_is_impossible(self, cr, uid, collumns):

		#if not ('parent_id' in collumns):

		#	return

		#parent = self.pool.get('personal.base.account.entry').read(cr, uid, collumns['parent_id'], ['date', 'currency_id'])

		try:

			new_id = self.create(cr, uid, collumns)

		except:

			cr.commit()

			return

		self.unlink(cr, uid, [new_id])

		assert False, "Entry Lines creation checked out not everything."

personal_account_entry_line()