def _compute_soma_itens(self):
        CAMPOS_SOMA_ITENS = [
            'vr_produtos', 'vr_produtos_tributacao',
            'vr_frete', 'vr_seguro', 'vr_desconto', 'vr_outras',
            'vr_operacao', 'vr_operacao_tributacao',
            'bc_icms_proprio', 'vr_icms_proprio',
            'vr_difal', 'vr_icms_estado_origem', 'vr_icms_estado_destino',
            'vr_fcp',
            'vr_icms_sn', 'vr_simples',
            'bc_icms_st', 'vr_icms_st',
            'bc_icms_st_retido', 'vr_icms_st_retido',
            'bc_ipi', 'vr_ipi',
            'bc_ii', 'vr_ii', 'vr_despesas_aduaneiras', 'vr_iof',
            'bc_pis_proprio', 'vr_pis_proprio',
            'bc_cofins_proprio', 'vr_cofins_proprio',
            'bc_iss', 'vr_iss',
            'vr_nf', 'vr_fatura',
            'vr_ibpt',
            'vr_custo_comercial'
        ]

        for documento in self:
            dados = {}
            for campo in CAMPOS_SOMA_ITENS:
                dados[campo] = D(0)

            for item in documento.item_ids:
                for campo in CAMPOS_SOMA_ITENS:
                    dados[campo] += getattr(item, campo, D(0))

            documento.update(dados)
Esempio n. 2
0
    def _monta_nfe_identificacao(self, ide):
        empresa = self.empresa_id
        participante = self.participante_id

        ide.tpAmb.valor = int(self.ambiente_nfe)
        ide.tpNF.valor = int(self.entrada_saida)
        ide.cUF.valor = UF_CODIGO[empresa.estado]
        ide.natOp.valor = self.natureza_operacao_id.nome
        ide.indPag.valor = int(self.ind_forma_pagamento)
        ide.serie.valor = self.serie
        ide.nNF.valor = str(D(self.numero).quantize(D('1')))

        #
        # Tratamento das datas de UTC para o horário de brasília
        #
        ide.dhEmi.valor = data_hora_horario_brasilia(
            parse_datetime(self.data_hora_emissao + ' GMT')
        )
        ide.dEmi.valor = ide.dhEmi.valor

        if self.data_hora_entrada_saida:
            ide.dhSaiEnt.valor = data_hora_horario_brasilia(
                parse_datetime(self.data_hora_entrada_saida + ' GMT')
            )
        else:
            nfe.infNFe.ide.dhSaiEnt.valor = data_hora_horario_brasilia(
                parse_datetime(self.data_hora_emissao + ' GMT')
            )

        ide.dSaiEnt.valor = ide.dhSaiEnt.valor
        ide.hSaiEnt.valor = ide.dhSaiEnt.valor

        ide.cMunFG.valor = empresa.municipio_id.codigo_ibge[:7]
        # ide.tpImp.valor = 1  # DANFE em retrato
        ide.tpEmis.valor = self.tipo_emissao_nfe
        ide.finNFe.valor = self.finalidade_nfe
        ide.procEmi.valor = 0  # Emissão por aplicativo próprio
        ide.verProc.valor = 'Odoo 10.0'
        ide.indPres.valor = self.presenca_comprador

        #
        # NFC-e é sempre emissão para dentro do estado
        # e sempre para consumidor final
        #
        if self.modelo == MODELO_FISCAL_NFCE:
            ide.idDest.valor = IDENTIFICACAO_DESTINO_INTERNO
            ide.indFinal.valor = TIPO_CONSUMIDOR_FINAL_CONSUMIDOR_FINAL

        else:
            if participante.estado == 'EX':
                ide.idDest.valor = IDENTIFICACAO_DESTINO_EXTERIOR
            elif participante.estado == empresa.estado:
                ide.idDest.valor = IDENTIFICACAO_DESTINO_INTERNO
            else:
                ide.idDest.valor = IDENTIFICACAO_DESTINO_INTERESTADUAL

            if (self.consumidor_final) or (
                        participante.contribuinte ==
                        INDICADOR_IE_DESTINATARIO_NAO_CONTRIBUINTE):
                ide.indFinal.valor = TIPO_CONSUMIDOR_FINAL_CONSUMIDOR_FINAL
Esempio n. 3
0
    def monta_nfe(self):
        self.ensure_one()

        if self.documento_id.modelo != MODELO_FISCAL_NFE and \
                self.documento_id.modelo != MODELO_FISCAL_NFCE:
            return

        di = DI_310()

        di.nDI.valor = self.numero_documento
        di.dDI.valor = self.data_registro[:10]
        di.xLocDesemb.valor = self.local_desembaraco
        di.UFDesemb.valor = self.uf_desembaraco_id.uf
        di.dDesemb.valor = self.data_desembaraco[:10]
        di.tpViaTransp.valor = self.via_trans_internacional
        di.vAFRMM.valor = D(self.vr_afrmm)
        di.tpIntermedio.valor = self.forma_importacao

        if self.participante_id:
            di.CNPJ.valor = limpa_formatacao(self.participante_id.cnpj_cpf)
            di.UFTerceiro.valor = self.participante_id.estado
            di.cExportador.valor = \
                limpa_formatacao(self.participante_id.cnpj_cpf)

        #
        # Sempre existe pelo menos uma adição
        #
        adi = Adi_310()

        adi.nAdicao.valor = self.numero_adicao
        adi.nSeqAdic.valor = self.sequencial

        if self.participante_id:
            adi.cFabricante.valor = \
                limpa_formatacao(self.participante_id.cnpj_cpf)

        adi.vDescDI.valor = D(self.vr_desconto)
        adi.nDraw.valor = self.numero_drawback

        di.adi.append(adi)

        #
        # Agora, se houver mais
        #
        for adicao in self.adicao_ids:
            adi = Adi_310()

            adi.nAdicao.valor = adicao.numero_adicao
            adi.nSeqAdic.valor = adicao.sequencial

            if self.participante_id:
                adi.cFabricante.valor = \
                    limpa_formatacao(self.participante_id.cnpj_cpf)

            adi.vDescDI.valor = D(adicao.vr_desconto)
            adi.nDraw.valor = adicao.numero_drawback

            di.adi.append(adi)

        return di
Esempio n. 4
0
 def round(self, amount):
     # self.ensure_one()
     amount = D(amount or 0)
     if (self.tipo == self.TIPO_UNIDADE_UNIDADE
             or self.tipo == self.TIPO_UNIDADE_EMBALAGEM):
         return amount.quantize(D(1))
     amount = amount.quantize(D(10) * D(self.decimal_places * -1))
     return amount
Esempio n. 5
0
def header_retorno_240(self, retorno):
    header = retorno.linhas[0]

    beneficiario = retorno.beneficiario

    beneficiario.cnpj_cpf = header[18:32]
    beneficiario.agencia.numero = str(D(header[52:57]))
    beneficiario.agencia.digito = header[57]
    beneficiario.conta.numero = str(D(header[58:70]))
    beneficiario.conta.digito = header[70]
    beneficiario.nome = header[72:102]
    retorno.data_hora = parse_datetime(header[143:151] + ' ' + header[151:157])
    retorno.sequencia = int(header[157:163])
Esempio n. 6
0
    def _monta_nfe_cobranca(self, cobr):
        if self.modelo != MODELO_FISCAL_NFE:
            return

        if self.ind_forma_pagamento not in \
                (IND_FORMA_PAGAMENTO_A_VISTA, IND_FORMA_PAGAMENTO_A_PRAZO):
            return
        cobr.fat.nFat.valor = formata_valor(self.numero, casas_decimais=0)
        cobr.fat.vOrig.valor = str(D(self.vr_operacao))
        cobr.fat.vDesc.valor = str(D(self.vr_desconto))
        cobr.fat.vLiq.valor = str(D(self.vr_fatura))

        for duplicata in self.duplicata_ids:
            cobr.dup.append(duplicata.monta_nfe())
    def write(self, dados):
        res = super(DecimalPrecision, self).write(dados)
        import ipdb; ipdb.set_trace();

        for dp in self:
            #
            # Mantém a sincronia entre as casas decimais dos campos float
            # e monetary
            #
            if dp.id == self.env.ref('sped.CASAS_DECIMAIS_UNITARIO').id:
                simbolo = self.env.ref('sped.SIMBOLO_VALOR_UNITARIO')
                arredondamento = D(10) ** (D(dp.digits or 0) * -1)
                simbolo.rounding = arredondamento

        return res
    def _compute_comercial_name(self):
        if self.env.context.get('currency_id'):
            currency = self.env['res.currency'].browse(
                self.env.context['currency_id'])
        else:
            currency = self.env.user.company_id.currency_id

        prec = D(10)**(D(currency.decimal_places or 2) * -1)

        if self.env.context.get('lang'):
            lang = self.env['res.lang']._lang_get(self.env.context.get('lang'))
        else:
            lang = self.env['res.lang']._lang_get('en')

        value = D(self.env.context.get('value') or 0)

        for payment_term in self:
            comercial_name = u''
            if payment_term.forma_pagamento in FORMA_PAGAMENTO_CARTOES:
                if payment_term.forma_pagamento == \
                    FORMA_PAGAMENTO_CARTAO_CREDITO:
                    comercial_name += u'[Crédito '
                elif payment_term.forma_pagamento == \
                    FORMA_PAGAMENTO_CARTAO_DEBITO:
                    comercial_name += u'[Débito '

                comercial_name += \
                    BANDEIRA_CARTAO_DICT[payment_term.bandeira_cartao]
                comercial_name += u'] '

            elif payment_term.forma_pagamento:
                comercial_name += u'['
                comercial_name += \
                    FORMA_PAGAMENTO_DICT[payment_term.forma_pagamento]
                comercial_name += u'] '

            comercial_name += payment_term.name

            if payment_term.is_installment_plan and value > 0:
                comercial_name += ' de '
                comercial_name += currency.symbol
                comercial_name += u' '
                installment_amount = value / D(payment_term.months or 1)
                installment_amount = installment_amount.quantize(prec)
                comercial_name += lang.format('%.2f', installment_amount, True,
                                              True)

            payment_term.comercial_name = comercial_name
    def compute(self, value, date_ref=False):
        self.ensure_one()

        if not self.is_installment_plan:
            return super(AccountPaymentTerm, self).compute(value,
                                                           date_ref=date_ref)

        date_ref = date_ref or fields.Date.today()
        value = D(value)
        months = D(self.months or 1)
        res = []

        if self.env.context.get('currency_id'):
            currency = self.env['res.currency'].browse(
                self.env.context['currency_id'])
        else:
            currency = self.env.user.company_id.currency_id

        prec = D(10)**(D(currency.decimal_places or 2) * -1)

        installment_amount = value / months
        installment_amount = installment_amount.quantize(prec)
        diff = value - (installment_amount * months)

        for i in range(months):
            next_date = fields.Date.from_string(date_ref)

            if self.has_down_payment:
                next_date += relativedelta(months=i)

            else:
                next_date += relativedelta(months=i + 1)

            installment = [
                fields.Date.to_string(next_date),
                installment_amount,
            ]

            if i == 0 and diff > 0:
                installment[1] += diff
                diff = 0

            elif i + 1 == months and diff != 0:
                installment[1] += diff

            res.append(installment)

        return res
Esempio n. 10
0
    def extenso(self, numero=D(0)):
        self.ensure_one()

        parametros = {
            'numero': numero,
            'unidade': ('unidade', 'unidades'),
            'genero_unidade_masculino': False,
            'precisao_decimal': self.precisao_decimal,
            'unidade_decimal': ('subunidade', 'subunidades'),
            'genero_unidade_decimal_masculino': False,
            'mascara_negativo': ('menos %s', 'menos %s'),
            'fator_relacao_decimal': self.fator_relacao_decimal or 10,
            'usa_meio': self.usa_meio,
            'usa_fracao': False,
            'usa_virgula': self.usa_virgula,
        }

        if self.usa_virgula:
            parametros['fator_relacao_decimal'] = 10
            parametros['precisao_decimal'] = 2

        if self.nome_singular and self.nome_plural:
            parametros['unidade'] = (self.nome_singular, self.nome_plural)
            parametros['genero_unidade_masculino'] = self.genero_masculino

        if (self.subunidade_id and self.subunidade_id.nome_singular
                and self.subunidade_id.nome_plural):
            parametros['unidade_decimal'] = (self.subunidade_id.nome_singular,
                                             self.subunidade_id.nome_plural)
            parametros['genero_unidade_decimal_masculino'] = (
                self.subunidade_id.genero_masculino)

        return valor_por_extenso_unidade(**parametros)
Esempio n. 11
0
    def write(self, dados):
        #
        # Validação do número máximo de casas decimais
        #
        if 'digits' in dados:
            for dp in self:
                if dp.id == \
                        self.env.ref(
                            'l10n_br_base.CASAS_DECIMAIS_QUANTIDADE').id:
                    if dados['digits'] > 4:
                        raise ValidationError(
                            'O número máximo de casas decimais para os ' +
                            'campos de quantidade é 4!')

                elif dp.id == \
                        self.env.ref(
                            'l10n_br_base.CASAS_DECIMAIS_UNITARIO').id:
                    if dados['digits'] > 11:
                        raise ValidationError(
                            'O número máximo de casas decimais para os ' +
                            'campos de valor unitário é 11!')

                elif dp.id == \
                        self.env.ref('l10n_br_base.CASAS_DECIMAIS_PESO').id:
                    if dados['digits'] > 4:
                        raise ValidationError(
                            'O número máximo de casas decimais para os ' +
                            'campos de peso é 4!')

        res = super(DecimalPrecision, self).write(dados)

        for dp in self:
            #
            # Mantém a sincronia entre as casas decimais dos campos float
            # e monetary
            #
            if dp.id == self.env.ref(
                    'l10n_br_base.CASAS_DECIMAIS_UNITARIO').id:
                simbolo = self.env.ref('l10n_br_base.SIMBOLO_VALOR_UNITARIO')
                arredondamento = D(10)**(D(dp.digits or 0) * -1)
                simbolo.rounding = arredondamento

            elif dp.id == self.env.ref('l10n_br_base.CASAS_DECIMAIS_PESO').id:
                simbolo = self.env.ref('l10n_br_base.SIMBOLO_PESO')
                arredondamento = D(10)**(D(dp.digits or 0) * -1)
                simbolo.rounding = arredondamento
        return res
    def monta_nfe(self):
        self.ensure_one()

        if self.documento_id.modelo != MODELO_FISCAL_NFE and \
                self.documento_id.modelo != MODELO_FISCAL_NFCE:
            return

        vol = Vol_310()

        vol.qVol.valor = str(D(self.quantidade or 0))
        vol.esp.valor = self.especie or ''
        vol.marca.valor = self.marca or ''
        vol.nVol.valor = self.numero or ''
        vol.pesoL.valor = str(D(self.peso_liquido or 0).quantize(D('0.001')))
        vol.pesoB.valor = str(D(self.peso_bruto or 0).quantize(D('0.001')))

        return vol
Esempio n. 13
0
def header_retorno_400(self, retorno):
    header = retorno.linhas[0]

    beneficiario = retorno.beneficiario

    beneficiario.codigo.numero = str(D(header[110:117]))
    beneficiario.nome = header[46:76]

    retorno.data_hora = parse_datetime(header[94:100]).date()
    retorno.sequencia = int(header[391:394])
Esempio n. 14
0
    def _calcula_valor_parcela(self, valor, meses, valor_entrada=0):
        self.ensure_one()

        #
        # Tratamento dos juros
        #
        if self.com_juros and self.al_juros:
            al_juros = D(self.al_juros) / 100
            valor_parcela = D(0)

            if valor_entrada > 0:
                if meses > 1:
                    fator_juros = 1 - ((1 + al_juros)**((meses - 1) * -1))
                    fator_juros /= al_juros
                    valor_parcela = (valor - valor_entrada) / fator_juros
            else:
                fator_juros = 1 - ((1 + al_juros)**(meses * -1))
                fator_juros /= al_juros
                valor_parcela = valor / fator_juros

            valor_parcela = valor_parcela.quantize(D('0.01'))

            if valor_entrada > 0:
                valor = valor_entrada + (valor_parcela * (meses - 1))
            else:
                valor = valor_parcela * meses

        #
        # Aponta o valor da parcela e a diferença em centavos a ser ajustada
        #
        if valor_entrada > 0:
            if meses > 1:
                valor_parcela = (valor - valor_entrada) / (meses - 1)
                valor_parcela = valor_parcela.quantize(D('0.01'))
                diferenca = valor - valor_entrada - \
                    (valor_parcela * (meses - 1))
        else:
            valor_parcela = valor / meses
            valor_parcela = valor_parcela.quantize(D('0.01'))
            diferenca = valor - (valor_parcela * meses)

        return valor_parcela, diferenca
Esempio n. 15
0
def header_retorno_400(self, retorno):
    header = retorno.linhas[0]

    beneficiario = retorno.beneficiario

    beneficiario.agencia.numero = header[26:30]
    beneficiario.agencia.digito = header[30]
    beneficiario.codigo.numero = str(D(header[31:39])).zfill(6)
    beneficiario.codigo.digito = header[39]
    beneficiario.nome = header[46:76]

    retorno.data_hora = parse_datetime(header[94:100]).date()
    retorno.sequencia = int(header[100:107])
Esempio n. 16
0
    def monta_nfe(self):
        self.ensure_one()

        if self.documento_id.modelo != MODELO_FISCAL_NFE and \
                self.documento_id.modelo != MODELO_FISCAL_NFCE:
            return

        dup = Dup_310()
        dup.nDup.valor = self.numero
        dup.dVenc.valor = self.data_vencimento
        dup.vDup.valor = str(D(self.valor))

        return dup
Esempio n. 17
0
def header_retorno_400(self, retorno):
    header = retorno.linhas[0]

    beneficiario = retorno.beneficiario

    #beneficiario.agencia.numero = header[26:30]
    #beneficiario.agencia.digito = header[30]
    beneficiario.codigo.numero = unicode(D(header[26:46]))
    #beneficiario.codigo.digito = header[39]
    beneficiario.nome = header[46:76]

    retorno.data_hora = parse_datetime(header[94:100]).date()
    retorno.sequencia = int(header[108:113])
Esempio n. 18
0
    def prepare_sync_to_currency(self):
        self.ensure_one()

        dados = {
            'name': self.nome + ' - UNIDADE',
            'symbol': self.codigo,
            'is_uom': True,
            'active': True,
            'position': 'after',
        }

        if self.fator_relacao_decimal == 10:
            casas_decimais = self.precisao_decimal
        else:
            casas_decimais = \
                self.env.ref('l10n_br_base.CASAS_DECIMAIS_QUANTIDADE').digits

        casas_decimais = D(casas_decimais or 0)

        dados['rounding'] = D(10) ** (casas_decimais * -1)

        return dados
    def _onchange_payment_term(self):
        res = {}
        valores = {}
        res['value'] = valores

        if not (self.payment_term_id and (self.vr_fatura or self.vr_nf) and
                self.data_emissao):
            return res

        valor = D(self.vr_fatura or 0)
        if not valor:
            valor = D(self.vr_nf or 0)

        #
        # Para a compatibilidade com a chamada original (super), que usa
        # o decorator deprecado api.one, pegamos aqui sempre o 1º elemento
        # da lista que vai ser retornada
        #
        lista_vencimentos = self.payment_term_id.compute(valor,
                                                         self.data_emissao)[0]

        duplicata_ids = [
            [5, False, {}],
        ]

        parcela = 1
        for data_vencimento, valor in lista_vencimentos:
            duplicata = {
                'numero': str(parcela),
                'data_vencimento': data_vencimento,
                'valor': valor,
            }
            duplicata_ids.append([0, False, duplicata])
            parcela += 1

        valores['duplicata_ids'] = duplicata_ids

        return res
Esempio n. 20
0
def header_retorno_400(self, retorno):
    header = retorno.linhas[0]

    beneficiario = retorno.beneficiario

    beneficiario.agencia.numero = header[27:30]
    beneficiario.agencia.digito = header[30]
    beneficiario.codigo.numero = str(D(header[31:39])).zfill(8)
    beneficiario.codigo.digito = header[36]
    beneficiario.nome = header[46:76]

    data =  header[94:98] + '20' + header[98:100]
    retorno.data_hora = parse_datetime(data).date()
    retorno.sequencia = int(header[101:107])
Esempio n. 21
0
    def _compute_symbol(self):
        for unidade in self:
            self.active = True
            self.position = 'after'
            self.symbol = u' ' + self.codigo

            if (self.tipo == self.TIPO_UNIDADE_UNIDADE
                    or self.tipo == self.TIPO_UNIDADE_EMBALAGEM):
                self.decimal_places = 0
            else:
                self.decimal_places = len(
                    str(
                        int(self.fator_relacao_decimal *
                            (10**self.precisao_decimal))))

            self.rounding = D(10)**(self.decimal_places * -1)
Esempio n. 22
0
    def _extenso(self):
        parametros = {
            'numero': 0,
            'unidade': ('unidade', 'unidades'),
            'genero_unidade_masculino': False,
            'precisao_decimal': 0,
            'unidade_decimal': ('subunidade', 'subunidades'),
            'genero_unidade_decimal_masculino': False,
            'mascara_negativo': ('menos %s', 'menos %s'),
            'fator_relacao_decimal': self.fator_relacao_decimal or 10,
            'usa_meio': self.usa_meio,
            'usa_fracao': False,
            'usa_virgula': self.usa_virgula,
        }

        if self.nome_singular and self.nome_plural:
            parametros['unidade'] = (self.nome_singular, self.nome_plural)
            parametros['genero_unidade_masculino'] = self.genero_masculino

        if self.subunidade_id and self.subunidade_id.nome_singular and self.subunidade_id.nome_plural:
            parametros['unidade_decimal'] = (self.subunidade_id.nome_singular, self.subunidade_id.nome_plural)
            parametros['genero_unidade_decimal_masculino'] = self.subunidade_id.genero_masculino

        self.extenso_zero = valor_por_extenso_unidade(**parametros)
        parametros['numero'] = D('1')
        self.extenso_singular_inteiro = valor_por_extenso_unidade(**parametros)
        parametros['numero'] = D('1234567')
        self.extenso_plural_inteiro = valor_por_extenso_unidade(**parametros)

        parametros['precisao_decimal'] = self.precisao_decimal or 0

        if self.usa_virgula:
            parametros['fator_relacao_decimal'] = 10
            parametros['precisao_decimal'] = 2

        if self.usa_meio or self.subunidade_id or self.usa_virgula:
            parametros['numero'] = D('1.5')
            self.extenso_singular_meio = valor_por_extenso_unidade(**parametros)
        else:
            self.extenso_singular_meio = self.extenso_singular_inteiro

        if self.subunidade_id or self.usa_virgula:
            parametros['numero'] = D('1.01')
            self.extenso_singular_um_decimo = valor_por_extenso_unidade(**parametros)
            parametros['numero'] = D('1.67')
            self.extenso_singular_decimal = valor_por_extenso_unidade(**parametros)
            parametros['numero'] = D('1234567.89')
            self.extenso_plural_decimal = valor_por_extenso_unidade(**parametros)
        else:
            self.extenso_singular_um_decimo = self.extenso_singular_inteiro
            self.extenso_singular_decimal = self.extenso_singular_inteiro
            self.extenso_plural_decimal = self.extenso_plural_inteiro
Esempio n. 23
0
    def monta_nfe(self):
        self.ensure_one()

        if self.documento_id.modelo != MODELO_FISCAL_NFE and \
                self.documento_id.modelo != MODELO_FISCAL_NFCE:
            return

        pag = Pag_310()
        pag.tPag.valor = self.forma_pagamento
        pag.vPag.valor = str(D(self.valor))
        # Troco somente na NF-e 4.00
        # pag.vTroco.valor = str(D(self.troco))

        if self.forma_pagamento in FORMA_PAGAMENTO_CARTOES:
            pag.card.CNPJ.valor = limpa_formatacao(self.cnpj_cpf or '')
            pag.card.tBand.valor = self.bandeira_cartao
            pag.card.cAut.valor = self.integracao_cartao

        return pag
Esempio n. 24
0
 def __init__(self,
              numero=0,
              unidade=('real', 'reais'),
              genero_unidade_masculino=True,
              precisao_decimal=2,
              unidade_decimal=('centavo', 'centavos'),
              genero_unidade_decimal_masculino=True,
              mascara_negativo=('menos %s', 'menos %s'),
              fator_relacao_decimal=10,
              usa_meio=False,
              usa_fracao=False,
              usa_virgula=False):
     self.numero = D(numero or 0)
     self.unidade = unidade
     self.genero_unidade_masculino = genero_unidade_masculino
     self.precisao_decimal = precisao_decimal
     self.fator_relacao_decimal = fator_relacao_decimal
     self.unidade_decimal = unidade_decimal
     self.genero_unidade_decimal_masculino = genero_unidade_decimal_masculino
     self.mascara_negativo = mascara_negativo
     self.usa_meio = usa_meio
     self.usa_fracao = usa_fracao
     self.usa_virgula = usa_virgula
Esempio n. 25
0
    def _centena_dezena_unidade(self, numero, tipo=CARDINAL, genero=MASCULINO):
        assert 0 <= numero < 1000

        #
        # Tratamento especial do número 100
        #
        if (numero == 100) and (tipo == CARDINAL):
            return self.CARDINAL_100_ISOLADO

        if numero in self.EXTENSO[tipo][genero]:
            return self.EXTENSO[tipo][genero][numero]

        potencia_10 = int(10**int(D(numero).log10()))
        cabeca = int(numero / potencia_10) * potencia_10
        corpo = int(numero % potencia_10)

        if tipo == CARDINAL:
            return self.EXTENSO[tipo][genero][
                cabeca] + ' e ' + self._centena_dezena_unidade(
                    corpo, tipo, genero)
        else:
            return self.EXTENSO[tipo][genero][
                cabeca] + ' ' + self._centena_dezena_unidade(
                    corpo, tipo, genero)
Esempio n. 26
0
    def monta_nfe(self, numero_item, nfe):
        self.ensure_one()

        if self.documento_id.modelo != MODELO_FISCAL_NFE and \
                self.documento_id.modelo != MODELO_FISCAL_NFCE:
            return

        det = Det_310()

        det.nItem.valor = numero_item
        det.prod.cProd.valor = \
            self.produto_id.codigo or str(self.produto_id.id)
        det.prod.cEAN.valor = self.produto_id.codigo_barras or ''

        #
        # O 1º item da NFC-e tem que ter uma descrição específica em
        # homologação
        #
        if self.documento_id.modelo == MODELO_FISCAL_NFCE and \
                self.documento_id.ambiente_nfe == AMBIENTE_NFE_HOMOLOGACAO:
            descricao = 'NOTA FISCAL EMITIDA EM AMBIENTE DE HOMOLOGACAO - ' \
                        'SEM VALOR FISCAL'

        else:
            if self.produto_descricao:
                descricao = self.produto_descricao
            else:
                descricao = self.produto_id.nome

        descricao = descricao.replace('—', '-').replace('–', '-')
        descricao = descricao.replace('”', '"').replace('“', '"')
        descricao = descricao.replace('’', u"'").replace('‘', u"'")
        descricao = descricao.replace('—', '-').replace('–', '-')
        det.prod.xProd.valor = descricao.strip()

        if self.produto_id.ncm_id:
            det.prod.NCM.valor = self.produto_id.ncm_id.codigo
            det.prod.EXTIPI.valor = self.produto_id.ncm_id.ex
        else:
            det.prod.NCM.valor = ''

        det.prod.CFOP.valor = self.cfop_id.codigo
        det.prod.uCom.valor = self.unidade_id.codigo
        det.prod.qCom.valor = str(D(self.quantidade).quantize(D('0.0001')))
        det.prod.vUnCom.valor = \
            str(D(self.vr_unitario).quantize(D(10 * 10 ** -10)))
        det.prod.vProd.valor = str(D(self.vr_produtos))
        det.prod.cEANTrib.valor = ''
        det.prod.uTrib.valor = det.prod.uCom.valor
        det.prod.qTrib.valor = det.prod.qCom.valor
        det.prod.vUnTrib.valor = det.prod.vUnCom.valor
        det.prod.vFrete.valor = str(D(self.vr_frete))
        det.prod.vSeg.valor = str(D(self.vr_seguro))
        det.prod.vOutro.valor = str(D(self.vr_outras))
        det.prod.vDesc.valor = str(D(self.vr_desconto))
        det.prod.xPed.valor = self.numero_pedido or ''
        det.prod.nItemPed.valor = self.numero_item_pedido or ''

        if self.compoe_total:
            det.prod.indTot.valor = '1'
        else:
            det.prod.indTot.valor = '0'

        #
        # Declaração de Importação
        #
        for declaracao in self.declaracao_ids:
            det.prod.DI.append(declaracao.monta_nfe())

        #
        # Impostos
        #
        det.imposto.vTotTrib.valor = str(D(self.vr_ibpt))

        #
        # Usa o regime tributário da NF e não da empresa, e trata o código
        # interno 3.1 para o lucro real, que na NF deve ir somente 3
        #
        det.imposto.ICMS.regime_tributario = \
            self.documento_id.regime_tributario[0]

        #
        # ICMS comum
        #
        det.imposto.ICMS.orig.valor = self.org_icms
        det.imposto.ICMS.CST.valor = self.cst_icms

        #
        # ICMS SIMPLES
        #
        if self.documento_id.regime_tributario == REGIME_TRIBUTARIO_SIMPLES:
            det.imposto.ICMS.CSOSN.valor = self.cst_icms_sn
            det.imposto.ICMS.pCredSN.valor = str(D(self.al_icms_sn))
            det.imposto.ICMS.vCredICMSSN.valor = str(D(self.vr_icms_sn))

        det.imposto.ICMS.modBC.valor = self.md_icms_proprio
        det.imposto.ICMS.pRedBC.valor = str(D(self.rd_icms_proprio))
        det.imposto.ICMS.vBC.valor = str(D(self.bc_icms_proprio))
        det.imposto.ICMS.pICMS.valor = str(D(self.al_icms_proprio))
        det.imposto.ICMS.vICMS.valor = str(D(self.vr_icms_proprio))
        det.imposto.ICMS.modBCST.valor = self.md_icms_st
        det.imposto.ICMS.pMVAST.valor = str(D(self.pr_icms_st))
        det.imposto.ICMS.pRedBCST.valor = str(D(self.rd_icms_st))
        det.imposto.ICMS.vBCST.valor = str(D(self.bc_icms_st))
        det.imposto.ICMS.pICMSST.valor = str(D(self.al_icms_st))
        det.imposto.ICMS.vICMSST.valor = str(D(self.vr_icms_st))
        # det.imposto.ICMS.motDesICMS.valor =
        # det.imposto.ICMS.vBCSTRet.valor = str(D(self.bc_icms_st_retido))
        # det.imposto.ICMS.vICMSSTRet.valor = str(D(self.vr_icms_st_retido))
        # det.imposto.ICMS.vBCSTDest.valor =
        # det.imposto.ICMS.vICMSSTDest.valor =
        # det.imposto.ICMS.UFST.valor =
        # det.imposto.ICMS.pBCOp.valor =

        if (self.cst_icms not in ST_ICMS_CALCULA_PROPRIO
                and self.cst_icms_sn not in ST_ICMS_SN_CALCULA_PROPRIO):
            det.imposto.ICMS.pICMS.valor = str(D(0))

        if self.documento_id.regime_tributario == REGIME_TRIBUTARIO_SIMPLES:
            if self.cst_icms_sn in ST_ICMS_CODIGO_CEST:
                if self.produto_id.cest_id:
                    det.prod.CEST.valor = self.produto_id.cest_id.codigo or ''

        else:
            if self.cst_icms in ST_ICMS_CODIGO_CEST:
                if self.produto_id.cest_id:
                    det.prod.CEST.valor = self.produto_id.cest_id.codigo or ''

        #
        # IPI
        #
        if ((self.documento_id.regime_tributario != REGIME_TRIBUTARIO_SIMPLES)
                and self.cst_ipi):
            det.imposto.IPI.cEnq.valor = self.enquadramento_ipi or '999'
            det.imposto.IPI.CST.valor = self.cst_ipi or ''
            det.imposto.IPI.vBC.valor = str(D(self.bc_ipi))
            # det.imposto.IPI.qUnid.valor = str(D(self.quantidade_tributacao))
            # det.imposto.IPI.vUnid.valor = str(D(self.al_ipi))
            det.imposto.IPI.pIPI.valor = str(D(self.al_ipi))
            det.imposto.IPI.vIPI.valor = str(D(self.vr_ipi))
        else:
            det.imposto.IPI.CST.valor = ''

        #
        # PIS e COFINS
        #
        det.imposto.PIS.CST.valor = self.cst_pis
        det.imposto.PIS.vBC.valor = str(D(self.bc_pis_proprio))
        det.imposto.PIS.pPIS.valor = str(D(self.al_pis_proprio))
        det.imposto.PIS.vPIS.valor = str(D(self.vr_pis_proprio))
        det.imposto.COFINS.CST.valor = self.cst_cofins
        det.imposto.COFINS.vBC.valor = str(D(self.bc_cofins_proprio))
        det.imposto.COFINS.pCOFINS.valor = str(D(self.al_cofins_proprio))
        det.imposto.COFINS.vCOFINS.valor = str(D(self.vr_cofins_proprio))

        #
        # Imposto de importação
        #
        det.imposto.II.vBC.valor = str(D(self.bc_ii))
        det.imposto.II.vII.valor = str(D(self.vr_ii))
        det.imposto.II.vDespAdu.valor = str(D(self.vr_despesas_aduaneiras))
        det.imposto.II.vIOF.valor = str(D(self.vr_iof))

        #
        # Prepara a observação do item
        #
        infcomplementar = self.infcomplementar or ''

        dados_infcomplementar = {
            'nf': self.documento_id,
            'item': self,
        }

        #
        # Crédito de ICMS do SIMPLES
        #
        if self.documento_id.regime_tributario == REGIME_TRIBUTARIO_SIMPLES \
            and self.cst_icms_sn in ST_ICMS_SN_CALCULA_CREDITO:
            if len(infcomplementar) > 0:
                infcomplementar += '\n'

            infcomplementar += 'Permite o aproveitamento de crédito de ' + \
                'ICMS no valor de R$ ${formata_valor(item.vr_icms_sn)},' + \
                ' correspondente à alíquota de ' + \
                '${formata_valor(item.al_icms_sn)}%, nos termos do art. 23'+ \
                ' da LC 123/2006;'

        #
        # Valor do IBPT
        #
        if self.vr_ibpt:
            if len(infcomplementar) > 0:
                infcomplementar += '\n'

            infcomplementar += 'Valor aproximado dos tributos: ' + \
                'R$ ${formata_valor(item.vr_ibpt)} (' + \
                '${formata_valor(item.al_ibpt)}%) - fonte: IBPT;'

        #
        # ICMS para UF de destino
        #
        if nfe.infNFe.ide.idDest.valor == \
            IDENTIFICACAO_DESTINO_INTERESTADUAL and \
            nfe.infNFe.ide.indFinal.valor == \
            TIPO_CONSUMIDOR_FINAL_CONSUMIDOR_FINAL and \
            nfe.infNFe.dest.indIEDest.valor == \
            INDICADOR_IE_DESTINATARIO_NAO_CONTRIBUINTE:

            det.imposto.ICMSUFDest.vBCUFDest.valor = \
                det.imposto.ICMS.vBC.valor
            det.imposto.ICMSUFDest.pFCPUFDest.valor = \
                str(D(self.al_fcp))
            det.imposto.ICMSUFDest.pICMSUFDest.valor = \
                str(D(self.al_interna_destino))
            det.imposto.ICMSUFDest.pICMSInter.valor = \
                str(D(self.al_icms_proprio))
            det.imposto.ICMSUFDest.pICMSInterPart.valor = \
                str(D(self.al_partilha_estado_destino))
            det.imposto.ICMSUFDest.vFCPUFDest.valor = \
                str(D(self.vr_fcp))
            det.imposto.ICMSUFDest.vICMSUFDest.valor = \
                str(D(self.vr_icms_estado_destino))
            det.imposto.ICMSUFDest.vICMSUFRemet.valor = \
                str(D(self.vr_icms_estado_origem))

            if len(infcomplementar) > 0:
                infcomplementar += '\n'

            infcomplementar += \
                'Partilha do ICMS de ' + \
                '${formata_valor(item.al_interna_destino)}% recolhida ' + \
                'conf. EC 87/2015: ' + \
                'R$ ${formata_valor(item.vr_icms_estado_destino)} para o ' + \
                'estado de ${nf.participante_id.estado} e ' + \
                'R$ ${formata_valor(item.vr_icms_estado_origem)} para o ' + \
                'estado de ${nf.empresa_id.estado}; Valor do diferencial ' + \
                'de alíquota (${formata_valor(item.al_difal)}%): ' + \
                'R$ ${formata_valor(item.vr_difal)};'

            if self.vr_fcp:
                infcomplementar += ' Fundo de combate à pobreza: R$ ' + \
                    '${formata_valor(item.vr_fcp)}'

        #
        # Aplica um template na observação do item
        #
        template = TemplateBrasil(infcomplementar.encode('utf-8'))
        infcomplementar = template.render(**dados_infcomplementar)
        det.infAdProd.valor = infcomplementar.decode('utf-8')

        return det
Esempio n. 27
0
 def _monta_nfe_total(self, total):
     total.ICMSTot.vBC.valor = str(D(self.bc_icms_proprio))
     total.ICMSTot.vICMS.valor = str(D(self.vr_icms_proprio))
     total.ICMSTot.vICMSDeson.valor = str(D('0'))
     total.ICMSTot.vFCPUFDest.valor = str(D(self.vr_fcp))
     total.ICMSTot.vICMSUFDest.valor = str(D(self.vr_icms_estado_destino))
     total.ICMSTot.vICMSUFRemet.valor = str(D(self.vr_icms_estado_origem))
     total.ICMSTot.vBCST.valor = str(D(self.bc_icms_st))
     total.ICMSTot.vST.valor = str(D(self.vr_icms_st))
     total.ICMSTot.vProd.valor = str(D(self.vr_produtos))
     total.ICMSTot.vFrete.valor = str(D(self.vr_frete))
     total.ICMSTot.vSeg.valor = str(D(self.vr_seguro))
     total.ICMSTot.vDesc.valor = str(D(self.vr_desconto))
     total.ICMSTot.vII.valor = str(D(self.vr_ii))
     total.ICMSTot.vIPI.valor = str(D(self.vr_ipi))
     total.ICMSTot.vPIS.valor = str(D(self.vr_pis_proprio))
     total.ICMSTot.vCOFINS.valor = str(D(self.vr_cofins_proprio))
     total.ICMSTot.vOutro.valor = str(D(self.vr_outras))
     total.ICMSTot.vNF.valor = str(D(self.vr_nf))
     total.ICMSTot.vTotTrib.valor = str(D(self.vr_ibpt or 0))
Esempio n. 28
0
def linha_retorno_240(self, retorno):
    beneficiario = retorno.beneficiario
    linha = retorno.linhas[1]

    #
    # Beneficiario
    #
    beneficiario.cnpj_cpf = linha[19:33]
    beneficiario.conta.numero = linha[64:71]
    beneficiario.conta.digito = linha[72]
    beneficiario.codigo.numero = linha[64:71]

    for i in range(1, len(retorno.linhas) - 1):
        linha = retorno.linhas[i]

        if linha[13] == 'T':

            boleto = Boleto()
            boleto.beneficiario = retorno.beneficiario
            boleto.banco = self
            boleto.nosso_numero = str(D(linha[37:57]))

            #boleto.nosso_numero_digito = linha[73]
            #boleto.parcela = int(linha[74:76])
            #boleto.documento.especie = linha[83:85]
            #boleto.banco.modalidade = linha[106:108]
            boleto.comando = linha[15:17]
            #print(boleto.comando)

            boleto.identificacao = linha[105:130].replace('id ', 'ID_')
            boleto.data_vencimento = parse_datetime(linha[73:81]).date()
            boleto.documento.valor = D(linha[81:96]) / D('100')
            boleto.pagador.cnpj_cpf = linha[133:148]

        elif linha[13] == 'U':

            #boleto.valor_despesa_cobranca = D(linha[181:188]) / D('100')
            boleto.valor_desconto = D(linha[32:47]) / D('100')
            boleto.valor_juros = D(linha[18:32]) / D('100')
            boleto.valor_recebido = D(linha[92:107]) / D('100')
            boleto.valor_outros_creditos = D(linha[122:137]) / D('100')
            boleto.data_ocorrencia = parse_datetime(linha[137:145])
            boleto.data_credito = parse_datetime(linha[145:153])
            retorno.boletos.append(boleto)

        else:
            continue
    def atualizar_tabela(self):
        self.ensure_one()

        sped_ncm = self.env['sped.ncm']
        sped_nbs = self.env['sped.nbs']
        sped_servico = self.env['sped.servico']
        sped_icms = self.env['sped.aliquota.icms.proprio']
        ibptax_ncm = self.env['sped.ibptax.ncm']
        ibptax_nbs = self.env['sped.ibptax.nbs']
        ibptax_servico = self.env['sped.ibptax.servico']

        versao = '17.1.A'
        arquivo = '/home/ari/tauga/tauga_addons/sped/data/ibptax/' \
            'TabelaIBPTax{uf}{versao}.csv'.format(
                uf=self.estado_id.uf, versao=versao)

        ncm_ids = ibptax_ncm.search([('ibptax_id', '=', self.id)])
        ncm_ids.unlink()

        nbs_ids = ibptax_nbs.search([('ibptax_id', '=', self.id)])
        nbs_ids.unlink()

        servico_ids = ibptax_servico.search([('ibptax_id', '=', self.id)])
        servico_ids.unlink()

        arq = open(arquivo, 'r')

        for linha in arq.readlines():
            codigo, ex, tipo, descricao, nacionalfederal, importadosfederal, \
                estadual, municipal, vigenciainicio, vigenciafim, chave, \
                versao, fonte = linha.decode('iso-8859-1').split(';')

            if tipo == '0':
                ncm_ids = sped_ncm.search([('codigo', '=', codigo),
                                           ('ex', '=', ex)])

                if len(ncm_ids) == 0:
                    dados = {
                        'codigo': codigo,
                        'ex': ex,
                        'descricao': descricao,
                    }
                    ncm_ids = sped_ncm.create(dados)

                icms_ids = sped_icms.search([('al_icms', '=', D(estadual))])

                dados = {
                    'ibptax_id': self.id,
                    'ncm_id': ncm_ids[0].id,
                    'al_ibpt_nacional': D(nacionalfederal),
                    'al_ibpt_internacional': D(importadosfederal),
                    'al_ibpt_estadual': D(estadual),
                    'al_icms_id': icms_ids[0].id if len(icms_ids) else False,
                }
                ibptax_ncm.create(dados)

            elif tipo == '1':
                nbs_ids = sped_nbs.search([('codigo', '=', codigo)])

                if len(nbs_ids) == 0:
                    dados = {
                        'codigo': codigo,
                        'descricao': descricao,
                    }
                    nbs_ids = sped_nbs.create(dados)

                dados = {
                    'ibptax_id': self.id,
                    'nbs_id': nbs_ids[0].id,
                    'al_ibpt_nacional': D(nacionalfederal),
                    'al_ibpt_internacional': D(importadosfederal),
                    'al_ibpt_municipal': D(municipal),
                }
                ibptax_nbs.create(dados)

            elif tipo == '2' and descricao != 'Vetado':
                servico_ids = sped_servico.search([('codigo', '=', codigo)])

                if len(servico_ids) == 0:
                    dados = {
                        'codigo': codigo,
                        'descricao': descricao,
                    }
                    servico_ids = sped_servico.create(dados)

                dados = {
                    'ibptax_id': self.id,
                    'servico_id': servico_ids[0].id,
                    'al_ibpt_nacional': D(nacionalfederal),
                    'al_ibpt_internacional': D(importadosfederal),
                    'al_ibpt_municipal': D(municipal),
                }
                ibptax_servico.create(dados)

        arq.close()
        self.data_validade = str(parse_datetime(vigenciafim))[:10]
        self.versao = versao
Esempio n. 30
0
def linha_retorno_400(self, retorno):
    beneficiario = retorno.beneficiario
    linha = retorno.linhas[1]

    #
    # Beneficiario
    #
    beneficiario.cnpj_cpf = linha[3:17]
    beneficiario.agencia.numero = linha[17:21]

    beneficiario.codigo.numero = linha[23:28]
    beneficiario.codigo.digito = linha[28]

    beneficiario.conta.numero = linha[23:28]
    beneficiario.conta.digito = linha[28]

    for i in range(1, len(retorno.linhas) - 1):
        linha = retorno.linhas[i]
        boleto = Boleto()
        boleto.beneficiario = retorno.beneficiario
        boleto.banco = self

        boleto.identificacao = linha[37:62]
        boleto.nosso_numero = str(D(linha[62:70]))
        boleto.comando = linha[108:110]
        boleto.data_ocorrencia = parse_datetime(linha[110:116])
        boleto.documento.numero = linha[116:126]

        if linha[146:152].strip() != '000000':
            boleto.data_vencimento = parse_datetime(linha[146:152]).date()

        boleto.documento.valor = D(linha[152:165]) / D('100')
        boleto.valor_despesa_cobranca = D(linha[175:188]) / D('100')
        #boleto.valor_outras_despesas = D(linha[188:201]) / D('100')
        #boleto.valor_multa = D(linha[188:201]) / D('100')
        boleto.valor_iof = D(linha[214:227]) / D('100')
        boleto.valor_abatimento = D(linha[227:240]) / D('100')
        boleto.valor_desconto = D(linha[240:253]) / D('100')
        boleto.valor_recebido = D(linha[253:266]) / D('100')
        boleto.valor_juros = D(linha[266:279]) / D('100')
        boleto.valor_outros_creditos = D(linha[279:292]) / D('100')

        if len(linha[295:301].strip()) > 0 and linha[295:301] != '000000':
            boleto.data_credito = parse_datetime(linha[295:301]).date()

        retorno.boletos.append(boleto)