Sign upLogin

OCA/l10n-italy

View on GitHub
Star

Showing 341 of 1,161 total issues

Function _export_xml_get_dte has 56 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    def _export_xml_get_dte(self):
        # ----- 2 - DTE
        x_2_dte = etree.Element(
            etree.QName("DTE"))
        # -----     2.1 - Cedente Prestatore DTE
Severity: Major
Found in l10n_it_invoices_data_communication/models/communication.py - About 2 hrs to fix

    Function _BuildAutomaton_2 has 56 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    def _BuildAutomaton_2 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_2
    del _BuildAutomaton_2
    import pyxb.utils.fac as fac
    Severity: Major
    Found in l10n_it_fatturapa/bindings/binding.py - About 2 hrs to fix

      Function _BuildAutomaton_34 has 55 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      def _BuildAutomaton_34 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_34
    del _BuildAutomaton_34
    import pyxb.utils.fac as fac
      Severity: Major
      Found in l10n_it_fatturapa/bindings/binding.py - About 2 hrs to fix

        Function _BuildAutomaton_ has 55 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        def _BuildAutomaton_ ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_
    del _BuildAutomaton_
    import pyxb.utils.fac as fac
        Severity: Major
        Found in l10n_it_fatturapa/bindings/binding.py - About 2 hrs to fix

          Function _BuildAutomaton_15 has 55 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          def _BuildAutomaton_15 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_15
    del _BuildAutomaton_15
    import pyxb.utils.fac as fac
          Severity: Major
          Found in l10n_it_fatturapa/bindings/binding.py - About 2 hrs to fix

            Function setUp has 53 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                def setUp(self):
        super(FatturaPACommon, self).setUp()
        self.seq_model = self.env['ir.sequence']
        self.res_user_model = self.env['res.users']
        self.company = self.env.ref('base.main_company')
            Severity: Major
            Found in l10n_it_fatturapa_out/tests/fatturapa_common.py - About 2 hrs to fix

              Function _compute_weight has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
              Open

                  def _compute_weight(self):
        res = super(StockPickingPackagePreparation, self)._compute_weight()
        if not self.package_id:
            quants = self.env['stock.quant']
            for picking in self.picking_ids:
              Severity: Minor
              Found in l10n_it_ddt/models/stock_picking_package_preparation.py - About 2 hrs to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Function check_ddt_data has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
              Open

                  def check_ddt_data(self, ddts):
        carriage_condition_id = False
        goods_description_id = False
        transportation_reason_id = False
        transportation_method_id = False
              Severity: Minor
              Found in l10n_it_ddt/wizard/ddt_create_invoice.py - About 2 hrs to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Function get_account_taxes has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
              Open

                  def get_account_taxes(self, AliquotaIVA, Natura):
        account_tax_model = self.env['account.tax']
        # check if a default tax exists and generate def_purchase_tax object
        ir_values = self.env['ir.values']
        company_id = self.env['res.company']._company_default_get(
              Severity: Minor
              Found in l10n_it_fatturapa_in/wizard/wizard_import_fatturapa.py - About 2 hrs to fix

              Cognitive Complexity

              Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

              A method's cognitive complexity is based on a few simple rules:

              • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
              • Code is considered more complex for each "break in the linear flow of the code"
              • Code is considered more complex when "flow breaking structures are nested"

              Further reading

              Function _BuildAutomaton_13 has 52 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              def _BuildAutomaton_13 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_13
    del _BuildAutomaton_13
    import pyxb.utils.fac as fac
              Severity: Major
              Found in l10n_it_fatturapa/bindings/_ds.py - About 2 hrs to fix

                Function test_e_invoice_ddt has 52 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                    def test_e_invoice_ddt(self):
        # 2 ordini, 2 DDT e 1 fattura differita
        self.so1 = self.env['sale.order'].create({
            'partner_id': self.res_partner_fatturapa_2.id,
            'partner_invoice_id': self.res_partner_fatturapa_2.id,
                Severity: Major
                Found in l10n_it_fatturapa_out_ddt/tests/test_fatturapa_ddt.py - About 2 hrs to fix

                  File account.py has 251 lines of code (exceeds 250 allowed). Consider refactoring.
                  Open

                  # -*- coding: utf-8 -*-
##############################################################################
#
#    Copyright (C) 2012 Andrea Cometa.
#    Email: info@andreacometa.it
                  Severity: Minor
                  Found in l10n_it_ricevute_bancarie/models/account/account.py - About 2 hrs to fix

                    Consider simplifying this complex logical expression.
                    Open

                                if fattura.partner_id:
                fattura.cedente_IdFiscaleIVA_IdPaese = \
                    fattura.partner_id.country_id.code or ''
                fattura.cedente_IdFiscaleIVA_IdCodice = \
                    fattura.partner_id.vat[2:] if fattura.partner_id.vat \
                    Severity: Critical
                    Found in l10n_it_invoices_data_communication/models/communication.py - About 2 hrs to fix

                      Function _BuildAutomaton_19 has 50 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      def _BuildAutomaton_19 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_19
    del _BuildAutomaton_19
    import pyxb.utils.fac as fac
                      Severity: Minor
                      Found in l10n_it_fatturapa/bindings/binding.py - About 2 hrs to fix

                        Function _BuildAutomaton_21 has 49 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                        def _BuildAutomaton_21 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_21
    del _BuildAutomaton_21
    import pyxb.utils.fac as fac
                        Severity: Minor
                        Found in l10n_it_fatturapa/bindings/binding.py - About 1 hr to fix

                          Function _BuildAutomaton_37 has 48 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                          def _BuildAutomaton_37 ():
    # Remove this helper function from the namespace after it is invoked
    global _BuildAutomaton_37
    del _BuildAutomaton_37
    import pyxb.utils.fac as fac
                          Severity: Minor
                          Found in l10n_it_fatturapa/bindings/binding.py - About 1 hr to fix

                            Function test_invoice has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
                            Open

                                def test_invoice(self):
        invoice = self.invoice_model.create({
            'date_invoice': self.recent_date,
            'partner_id': self.env.ref('base.res_partner_3').id,
            'journal_id': self.sales_journal.id,
                            Severity: Minor
                            Found in l10n_it_split_payment/tests/test_splitpayment.py - About 1 hr to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Function _prepareWelfareLine has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
                            Open

                                def _prepareWelfareLine(self, invoice_id, line):
        TipoCassa = line.TipoCassa or False
        AlCassa = line.AlCassa and (float(line.AlCassa)/100) or None
        ImportoContributoCassa = (
            line.ImportoContributoCassa and
                            Severity: Minor
                            Found in l10n_it_fatturapa_in/wizard/wizard_import_fatturapa.py - About 1 hr to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Function _get_account_mappings has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
                            Open

                                def _get_account_mappings(self, cr, uid, fyc, mapping, context):
        """
        Transforms the mapping dictionary on a list of mapping lines.
        """
        account_mappings = []
                            Severity: Minor
                            Found in account_fiscal_year_closing/fyc.py - About 1 hr to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Function _export_xml_get_dte has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
                            Open

                                def _export_xml_get_dte(self):
        # ----- 2 - DTE
        x_2_dte = etree.Element(
            etree.QName("DTE"))
        # -----     2.1 - Cedente Prestatore DTE
                            Severity: Minor
                            Found in l10n_it_invoices_data_communication/models/communication.py - About 1 hr to fix

                            Cognitive Complexity

                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                            A method's cognitive complexity is based on a few simple rules:

                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                            • Code is considered more complex for each "break in the linear flow of the code"
                            • Code is considered more complex when "flow breaking structures are nested"

                            Further reading

                            Severity
                            Category
                            Status
                            Source
                            Language