eiru_account_bank_statement_utility/models/account_bank_statement_utility.py

# -*- coding: utf-8 -*-
from openerp import models, fields, tools, api
from datetime import datetime
from pytz import timezone

DATE_FORMAT = '%Y-%m-%d'

class AccountBankStatementUtility(models.Model):
    _inherit = 'account.bank.statement'

    '''
        get_account_bank_statement_utility
    '''
    @api.model
    def get_account_bank_statement_utility(self, id):
        '''
            Get Account Bank Statement
            :param : id: id account bank statement,
            :return : Object Account bank statement + Amount(account Bank statement line)
        '''
        decimal_precision = self.env['decimal.precision'].precision_get('Account')
        bankStatement = self.env['account.bank.statement'].browse(id)

        if (not bankStatement):
            return False

        accountStatement = []
        amount = 0.0

        for line in bankStatement.line_ids:
            amount += line.amount

        if (bankStatement.balance_start > 0):
            amount += bankStatement.balance_start

        accountStatement.append({
            'id': bankStatement.id,
            'name': bankStatement.name,
            'date': bankStatement.date,
            'journalId': bankStatement.journal_id.id,
            'periodId': bankStatement.period_id.id,
            'userId': bankStatement.user_id.id,
            'userName': bankStatement.user_id.name,
            'typeStatement': bankStatement.type_statement.id,
            'typeStatementName': bankStatement.type_statement.name,
            'state': bankStatement.state,
            'amount': amount,
            'currencystatement': {
                'id': bankStatement.currency.id,
                'symbol': bankStatement.currency.symbol,
                'rate': bankStatement.currency.rate,
                'thousandsSeparator': bankStatement.currency.thousands_separator,
                'decimalSeparator': bankStatement.currency.decimal_separator,
                'decimalPlaces': bankStatement.currency.decimal_places,
                'position': bankStatement.currency.position,
            },
        })

        return accountStatement

    @api.model
    def get_account_journal_utility(self,id):
        bankStatement = self.env['account.bank.statement'].browse(id)
        if (not bankStatement):
            return False

        domain = [('active', '=', True), ('type', 'in', ['bank', 'cash']), ('id', 'in', [bankStatement.journal_id.id])];

        accountJournal = self.env['account.journal'].search(domain)
        journalUtility = []
        for journal in accountJournal:

            domainStatment = [('id','!=',bankStatement.id),('journal_id','in',[journal.id])]
            # domainStatment = [('id','!=',bankStatement.id) ,('journal_id','in',[journal.id]),('date','=',bankStatement.date),('period_id','=',bankStatement.period_id.id)]

            if (journal.type == 'cash'):
                domainStatment.append(('state','=', 'open'))

            if (journal.type == 'bank'):
                domainStatment.append(('state','!=','confirm'))

            statementJournal = []

            statement = self.env['account.bank.statement'].search(domainStatment)

            for statementOpen in statement:
                statementJournal.append({
                        'id': statementOpen.id,
                        'journalId': statementOpen.journal_id.id,
                        'date': statementOpen.date,
                        'typeStatementId': statementOpen.type_statement.id,
                        'typeStatementName': statementOpen.type_statement.name,
                        'userId': statementOpen.user_id.id,
                        'userName': statementOpen.user_id.name,
                        'name': statementOpen.name,
                        'state': statementOpen.state,
                        'statementname': statementOpen.name+" / "+statementOpen.user_id.name
                })

            journalUtility.append({
                'id': journal.id,
                'name': journal.name,
                'code': journal.code,
                'type': journal.type,
                'currencyId': journal.currency.id,
                'statementJournal': statementJournal
            })

        return journalUtility

    '''
        Get User Login
    '''
    @api.model
    def eiru_transfers_get_user(self):
        return  [{
            'id': user.id,
            'name': user.name
        } for user in self.env.user]

    @api.model
    def eiru_transfers_get_chas_box_transfer(self, id):
        return [{
            'id': transfer.id,
            'name': transfer.name,
            'amount': transfer.amount,
            'ref': transfer.ref,
            'date': transfer.date,
            'outputStatement': {
                'id': transfer.output_statement.id,
                'name': transfer.output_statement.name,
                'typeJournal': transfer.output_statement.journal_id.type,
                'state': transfer.output_statement.state,
                'date': transfer.output_statement.date,
                'userId': transfer.output_statement.user_id.id,
                'currency': {
                    'symbol': transfer.output_statement.currency.symbol,
                    'thousandsSeparator': transfer.output_statement.currency.thousands_separator,
                    'decimalSeparator': transfer.output_statement.currency.decimal_separator,
                    'decimalPlaces': transfer.output_statement.currency.decimal_places,
                }
            },
            'inputStatement': {
                'id': transfer.input_statement.id,
                'name': transfer.input_statement.name,
                'state': transfer.input_statement.state,
                'typeJournal': transfer.input_statement.journal_id.type,
                'date': transfer.input_statement.date,
                'userId': transfer.input_statement.user_id.id,
                'currency': {
                    'symbol': transfer.input_statement.currency.symbol,
                    'thousandsSeparator': transfer.input_statement.currency.thousands_separator,
                    'decimalSeparator': transfer.input_statement.currency.decimal_separator,
                    'decimalPlaces': transfer.input_statement.currency.decimal_places,
                }
            },
            'outputLine': {
                'id': transfer.output_line.id,
                'statementID': transfer.output_line.statement_id.id,
            },
            'inputLine': {
                'id': transfer.input_line.id,
                'statementID': transfer.input_line.statement_id.id,
            }
        } for transfer in self.env['cash.box.transfer'].search(['|', ('output_statement.id','=',id), ('input_statement.id','=',id)])]

    '''       _____                     __
             |_   _| __ __ _ _ __  ___ / _| ___ _ __ ___
               | || '__/ _` | '_ \/ __| |_ / _ \ '__/ __|
               | || | | (_| | | | \__ \  _|  __/ |  \__ \
               |_||_|  \__,_|_| |_|___/_|  \___|_|  |___/
    '''
    '''
        Get Account Bank Statement
    '''
    def _get_statement_transfer(self,id):
        return self.env['account.bank.statement'].browse(id)

    '''
        Get Account Journal
    '''
    def _get_journal_transfer(self, id):
        return self.env['account.journal'].browse(id)

    '''
        Create Line statement.
    '''
    def _create_statement_line_transfer(self, statement, name, amount, ref):
        statementLine = {
            'statement_id': statement.id,
            'name': name,
            'amount': amount ,
            'ref': ref,
            'account_id': statement.journal_id.internal_account_id.id,
            'journal_id': statement.journal_id.id,
            'is_deleted': True
        }

        line = self.env['account.bank.statement.line'].create(statementLine)
        return line


    '''
        Create cash box transfer
    '''
    def _create_cash_box_transfer(self, ref, amount, lineInput, lineOutput):
        cash = {
            'name': "TRANSFERENCIA %s a %s" %((lineOutput.statement_id.name),(lineInput.statement_id.name)),
            'amount': amount,
            'ref': ref,
            'input_line': lineInput.id,
            'output_line': lineOutput.id,
            'input_statement': lineInput.statement_id.id,
            'output_statement': lineOutput.statement_id.id,
            'date': lineOutput.date
        }
        return self.env['cash.box.transfer'].create(cash)

    '''
        Create Line statement Transfer
    '''
    @api.model
    def statement_complet_transfers(self, values):
        statementOrigin = self._get_statement_transfer(values['statementOriginId'])
        if (not statementOrigin):
            return False

        statementDestiny = self._get_statement_transfer(values['statementDestinyId'])
        if (not statementDestiny):
            return False

        accountJournal = self._get_journal_transfer(values['journalID'])
        if (not accountJournal):
            return False

        # output
        name = "TRANSFERENCIA/"+str(statementDestiny.name)
        statementOutput = self._create_statement_line_transfer(statementOrigin, name,(-values['amountTransfer']), values['refTransfer'])
        if (not statementOutput):
            return False

        # input
        name = "TRANSFERENCIA/"+str(statementOrigin.name)
        statementInput = self._create_statement_line_transfer(statementDestiny, name, abs(values['amountTransfer']), values['refTransfer'])
        if (not statementInput):
            return False

        cash_box_transfer = self._create_cash_box_transfer(values['refTransfer'], abs(values['amountTransfer']), statementInput, statementOutput)
        if (not cash_box_transfer):
            return False

        return True

    '''
          _   _       _ _       _      _____                     __
         | | | |_ __ | (_)_ __ | | __ |_   _| __ __ _ _ __  ___ / _| ___ _ __
         | | | | '_ \| | | '_ \| |/ /   | || '__/ _` | '_ \/ __| |_ / _ \ '__|
         | |_| | | | | | | | | |   <    | || | | (_| | | | \__ \  _|  __/ |
          \___/|_| |_|_|_|_| |_|_|\_\   |_||_|  \__,_|_| |_|___/_|  \___|_|
    '''
    '''
        Get Cash Box Transfer
    '''
    def _get_cash_box_transfer(self, id):
        return self.env['cash.box.transfer'].browse(id)

    '''
        Get timezone
    '''
    def get_timezone(self):
        tz_name = self._context.get('tz') or self.env.user.tz
        return timezone(tz_name)

    '''
        Get server date
    '''
    def get_server_datetime(self):
        return datetime.now(self.get_timezone()).strftime(DATE_FORMAT)

    '''
        Get Statement Line
    '''
    def _get_statement_Line(self, id):
        return self.env['account.bank.statement.line'].browse(id)

    '''
        writer Line Statement
    '''
    def _write_statement_line_transfer(self, line):
        return line.write({
            'is_deleted': False
        })

    '''
        Unlink Line Statement
    '''
    def _unlink_statement_line_transfer(self, line):
        return line.unlink()

    '''
        Write cash box transfer
    '''
    def _write_cash_box_transfer(self, transfer, message, user):
        return transfer.write({
            'message_deleted': message,
            'active': False,
            'write_uid': user.id
        })

    '''
        unlink Initial
    '''
    @api.model
    def unlink_transfer(self, values):
        ### user
        user = self.env.user
        ### date server
        date_server = self.get_server_datetime()
        ### account Statement
        statement = self._get_statement_transfer(values['statementId'])
        if (not statement):
            return {
                'state' : False,
                'message': "No se pudo completar la operación."
            }

        ### Transferencia
        cashBoxTransfer =  self._get_cash_box_transfer(values['transferId'])
        if (not cashBoxTransfer):
            return {
                'state' : False,
                'message': "No se pudo completar la operación."
            }

        ### Line output
        lineOutput = self._get_statement_Line(cashBoxTransfer.output_line.id)
        if (not lineOutput):
            return {
                'state' : False,
                'message': "No se pudo completar la operación."
            }

        if (lineOutput.statement_id.state == 'confirm'):
            return {
                'state' : False,
                'message': "No se pudo completar la operación, por que la caja de origen ya fue cerrada"
            }

        ### Line Input
        lineInput = self._get_statement_Line(cashBoxTransfer.input_line.id)
        if (not lineInput):
            return {
                'state' : False,
                'message': "No se pudo completar la operación."
            }

        if (lineInput.statement_id.state == 'confirm'):
            return {
                'state' : False,
                'message': "No se pudo completar la operación por que la caja destino ya fue cerrada"
            }

        ## updtae
        writeOutput = self._write_statement_line_transfer(lineOutput)
        ## unlink
        unlinkOutpu = self._unlink_statement_line_transfer(lineOutput)
        if (not unlinkOutpu):
            return {
                'state' : False,
                'message': "No se pudo completar la operación, error al eliminar la transferencia"
            }
        ## Update
        writeInput = self._write_statement_line_transfer(lineInput)
        ## Unlink
        unlinkInput = self._unlink_statement_line_transfer(lineInput)
        if (not unlinkInput):
            return {
                'state' : False,
                'message': "No se pudo completar la operación, error al eliminar la transferencia"
            }

        message = values['comment']+" \nEliminado por la caja "+str(statement.name)+" y por Usuario "+str(user.name)+" en "+str(date_server)

        writeTransfer = self._write_cash_box_transfer(cashBoxTransfer, message, user)
        if (not writeTransfer):
            return {
                'state' : False,
                'message': "No se pudo completar la operación"
            }

        return { 'state': True,
                'message': 'Operación realizada con éxito'
        }

    '''
       ____          ____               ___                  ___        _
      / ___|__ _ ___| __ )  _____  __  |_ _|_ __            / _ \ _   _| |_
     | |   / _` / __|  _ \ / _ \ \/ /   | || '_ \   _____  | | | | | | | __|
     | |__| (_| \__ \ |_) | (_) >  <    | || | | | |_____| | |_| | |_| | |_
      \____\__,_|___/____/ \___/_/\_\  |___|_| |_|          \___/ \__,_|\__|

    '''
    '''
        Create Statement Line
    '''
    def _create_statement_line_input_outup(self, statement,ref,amount,type,name):
        statementLine = {
            'statement_id': statement.id,
            'name': name,
            'amount': type in ('input') and amount or -amount,
            'ref': ref,
            'account_id': statement.journal_id.internal_account_id.id,
            'journal_id': statement.journal_id.id,
            'is_deleted': True
        }

        line = self.env['account.bank.statement.line'].create(statementLine)
        return line

    '''
        Create cashBox input
    '''
    def create_cash_box_in_out(self, line, amount, ref, name, type):
        cash = {
            'name': "%s %s" %((name),(line.statement_id.name)),
            'amount': amount,
            'ref': ref,
            'date': line.date,
            'line_id': line.id,
            'statement_id': line.statement_id.id,
        }
        if (type =='input'):
            return self.env['cash.box.in'].create(cash)
        else:
            return self.env['cash.box.out'].create(cash)

    '''
        Create casbox input/output
    '''
    @api.model
    def create_cash_box_input_output(self, values):
        statement = self._get_statement_transfer(values['statementId'])
        if (not statement):
            return False

        name = values['type'] in ('input') and 'Entrada de Dinero' or 'Salida de Dinero'

        lineStatement = self._create_statement_line_input_outup(statement, values['ref'], values['amount'], values['type'], name)
        if (not lineStatement):
            return False

        casBox = self.create_cash_box_in_out(lineStatement, values['amount'], values['ref'], name, values['type'])

        if (not casBox):
            return False

        return {
            'state': True
        }