Sign upLogin

MyEMS/myems

View on GitHub
Star
myems-api/core/meter.py

Summary

Maintainability
F
1 mo
Test Coverage

File meter.py has 1559 lines of code (exceeds 250 allowed). Consider refactoring.
Open

import uuid
from datetime import datetime, timedelta
import falcon
import mysql.connector
import simplejson as json
Severity: Major
Found in myems-api/core/meter.py - About 4 days to fix

    Function on_post has a Cognitive Complexity of 67 (exceeds 5 allowed). Consider refactoring.
    Open

        def on_post(req, resp):
        """Handles POST requests"""
        admin_control(req)
        try:
            raw_json = req.stream.read().decode('utf-8')
    Severity: Minor
    Found in myems-api/core/meter.py - About 1 day 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 on_put has a Cognitive Complexity of 45 (exceeds 5 allowed). Consider refactoring.
    Open

        def on_put(req, resp, id_):
        """Handles PUT requests"""
        admin_control(req)
        try:
            raw_json = req.stream.read().decode('utf-8')
    Severity: Minor
    Found in myems-api/core/meter.py - About 6 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 on_post has a Cognitive Complexity of 40 (exceeds 5 allowed). Consider refactoring.
    Open

        def on_post(req, resp):
        """Handles POST requests"""
        admin_control(req)
        try:
            raw_json = req.stream.read().decode('utf-8')
    Severity: Minor
    Found in myems-api/core/meter.py - About 6 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 on_post has a Cognitive Complexity of 37 (exceeds 5 allowed). Consider refactoring.
    Open

        def on_post(req, resp, id_):
        """Handles POST requests"""
        admin_control(req)
        if not id_.isdigit() or int(id_) <= 0:
            raise falcon.HTTPError(status=falcon.HTTP_400, title='API.BAD_REQUEST',
    Severity: Minor
    Found in myems-api/core/meter.py - About 5 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 on_get has a Cognitive Complexity of 29 (exceeds 5 allowed). Consider refactoring.
    Open

        def on_get(req, resp, id_):
        if 'API-KEY' not in req.headers or \
                not isinstance(req.headers['API-KEY'], str) or \
                len(str.strip(req.headers['API-KEY'])) == 0:
            access_control(req)
    Severity: Minor
    Found in myems-api/core/meter.py - About 4 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 on_get has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.
    Open

        def on_get(req, resp):
        if 'API-KEY' not in req.headers or \
                not isinstance(req.headers['API-KEY'], str) or \
                len(str.strip(req.headers['API-KEY'])) == 0:
            access_control(req)
    Severity: Minor
    Found in myems-api/core/meter.py - About 3 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 on_get has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.
    Open

        def on_get(req, resp, id_):
        if 'API-KEY' not in req.headers or \
                not isinstance(req.headers['API-KEY'], str) or \
                len(str.strip(req.headers['API-KEY'])) == 0:
            access_control(req)
    Severity: Minor
    Found in myems-api/core/meter.py - About 3 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 on_get has a Cognitive Complexity of 24 (exceeds 5 allowed). Consider refactoring.
    Open

        def on_get(req, resp, id_):
        if 'API-KEY' not in req.headers or \
                not isinstance(req.headers['API-KEY'], str) or \
                len(str.strip(req.headers['API-KEY'])) == 0:
            access_control(req)
    Severity: Minor
    Found in myems-api/core/meter.py - About 3 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 on_delete has a Cognitive Complexity of 23 (exceeds 5 allowed). Consider refactoring.
    Open

        def on_delete(req, resp, id_):
        admin_control(req)
        if not id_.isdigit() or int(id_) <= 0:
            raise falcon.HTTPError(status=falcon.HTTP_400, title='API.BAD_REQUEST',
                                   description='API.INVALID_METER_ID')
    Severity: Minor
    Found in myems-api/core/meter.py - About 3 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 on_delete has 49 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        def on_delete(req, resp, id_):
        admin_control(req)
        if not id_.isdigit() or int(id_) <= 0:
            raise falcon.HTTPError(status=falcon.HTTP_400, title='API.BAD_REQUEST',
                                   description='API.INVALID_METER_ID')
    Severity: Minor
    Found in myems-api/core/meter.py - About 1 hr to fix

      Function on_post has 41 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          def on_post(req, resp):
        """Handles POST requests"""
        admin_control(req)
        try:
            raw_json = req.stream.read().decode('utf-8')
      Severity: Minor
      Found in myems-api/core/meter.py - About 1 hr to fix

        Function on_put has 39 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            def on_put(req, resp, id_):
        """Handles PUT requests"""
        admin_control(req)
        try:
            raw_json = req.stream.read().decode('utf-8')
        Severity: Minor
        Found in myems-api/core/meter.py - About 1 hr to fix

          Function on_post has 38 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              def on_post(req, resp):
        """Handles POST requests"""
        admin_control(req)
        try:
            raw_json = req.stream.read().decode('utf-8')
          Severity: Minor
          Found in myems-api/core/meter.py - About 1 hr to fix

            Function on_get has 31 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                def on_get(req, resp):
        if 'API-KEY' not in req.headers or \
                not isinstance(req.headers['API-KEY'], str) or \
                len(str.strip(req.headers['API-KEY'])) == 0:
            access_control(req)
            Severity: Minor
            Found in myems-api/core/meter.py - About 1 hr to fix

              Function on_get has 31 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  def on_get(req, resp, id_):
        if 'API-KEY' not in req.headers or \
                not isinstance(req.headers['API-KEY'], str) or \
                len(str.strip(req.headers['API-KEY'])) == 0:
            access_control(req)
              Severity: Minor
              Found in myems-api/core/meter.py - About 1 hr to fix

                Function on_get has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                    def on_get(req, resp, id_):
        if 'API-KEY' not in req.headers or \
                not isinstance(req.headers['API-KEY'], str) or \
                len(str.strip(req.headers['API-KEY'])) == 0:
            access_control(req)
                Severity: Minor
                Found in myems-api/core/meter.py - About 1 hr to fix

                  Function on_get has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      def on_get(req, resp, id_):
        if 'API-KEY' not in req.headers or \
                not isinstance(req.headers['API-KEY'], str) or \
                len(str.strip(req.headers['API-KEY'])) == 0:
            access_control(req)
                  Severity: Minor
                  Found in myems-api/core/meter.py - About 1 hr to fix

                    Function on_post has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
                    Open

                        def on_post(req, resp, id_):
        """Handles POST requests"""
        admin_control(req)
        try:
            raw_json = req.stream.read().decode('utf-8')
                    Severity: Minor
                    Found in myems-api/core/meter.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 on_post has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                        def on_post(req, resp, id_):
        """Handles POST requests"""
        admin_control(req)
        if not id_.isdigit() or int(id_) <= 0:
            raise falcon.HTTPError(status=falcon.HTTP_400, title='API.BAD_REQUEST',
                    Severity: Minor
                    Found in myems-api/core/meter.py - About 1 hr to fix

                      Function on_get has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                      Open

                          def on_get(req, resp, id_):
        if 'API-KEY' not in req.headers or \
                not isinstance(req.headers['API-KEY'], str) or \
                len(str.strip(req.headers['API-KEY'])) == 0:
            access_control(req)
                      Severity: Minor
                      Found in myems-api/core/meter.py - About 55 mins 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

                      Avoid deeply nested control flow statements.
                      Open

                                              if rows_points is not None and len(rows_points) > 0:
                            cursor.close()
                            cnx.close()
                            raise falcon.HTTPError(status=falcon.HTTP_400, title='API.ERROR',
                                                   description=
                      Severity: Major
                      Found in myems-api/core/meter.py - About 45 mins to fix

                        Function on_get has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                        Open

                            def on_get(req, resp, id_):
        if 'API-KEY' not in req.headers or \
                not isinstance(req.headers['API-KEY'], str) or \
                len(str.strip(req.headers['API-KEY'])) == 0:
            access_control(req)
                        Severity: Minor
                        Found in myems-api/core/meter.py - About 45 mins 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

                        Avoid deeply nested control flow statements.
                        Open

                                                if rows_points is not None and len(rows_points) > 0:
                            cursor.close()
                            cnx.close()
                            raise falcon.HTTPError(status=falcon.HTTP_400, title='API.ERROR',
                                                   description=
                        Severity: Major
                        Found in myems-api/core/meter.py - About 45 mins to fix

                          Function on_post has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                          Open

                              def on_post(req, resp, id_):
        """Handles POST requests"""
        admin_control(req)
        try:
            raw_json = req.stream.read().decode('utf-8')
                          Severity: Minor
                          Found in myems-api/core/meter.py - About 35 mins 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 on_delete has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                          Open

                              def on_delete(req, resp, id_, cid):
        admin_control(req)
        if not id_.isdigit() or int(id_) <= 0:
            raise falcon.HTTPError(status=falcon.HTTP_400, title='API.BAD_REQUEST',
                                   description='API.INVALID_METER_ID')
                          Severity: Minor
                          Found in myems-api/core/meter.py - About 25 mins 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 on_delete has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                          Open

                              def on_delete(req, resp, id_, pid):
        """Handles DELETE requests"""
        admin_control(req)
        if not id_.isdigit() or int(id_) <= 0:
            raise falcon.HTTPError(status=falcon.HTTP_400, title='API.BAD_REQUEST',
                          Severity: Minor
                          Found in myems-api/core/meter.py - About 25 mins 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

                          Similar blocks of code found in 24 locations. Consider refactoring.
                          Open

                          class MeterCommandCollection:
    def __init__(self):
        """Initializes Class"""
        pass
                          Severity: Major
                          Found in myems-api/core/meter.py and 23 other locations - About 1 wk to fix
                          myems-api/core/combinedequipment.py on lines 2098..2210
                          myems-api/core/equipment.py on lines 1914..2028
                          myems-api/core/shopfloor.py on lines 458..570
                          myems-api/core/shopfloor.py on lines 1199..1311
                          myems-api/core/shopfloor.py on lines 1563..1675
                          myems-api/core/shopfloor.py on lines 1739..1851
                          myems-api/core/space.py on lines 817..929
                          myems-api/core/space.py on lines 993..1105
                          myems-api/core/space.py on lines 1169..1281
                          myems-api/core/space.py on lines 1534..1646
                          myems-api/core/space.py on lines 2087..2199
                          myems-api/core/space.py on lines 2262..2374
                          myems-api/core/space.py on lines 2437..2549
                          myems-api/core/space.py on lines 2612..2724
                          myems-api/core/space.py on lines 3161..3273
                          myems-api/core/space.py on lines 3337..3449
                          myems-api/core/store.py on lines 1142..1254
                          myems-api/core/store.py on lines 1506..1618
                          myems-api/core/store.py on lines 1682..1794
                          myems-api/core/tenant.py on lines 1246..1360
                          myems-api/core/tenant.py on lines 1614..1728
                          myems-api/core/tenant.py on lines 1792..1906
                          myems-api/core/virtualpowerplant.py on lines 435..547

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 873.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 2 locations. Consider refactoring.
                          Open

                          class MeterPointItem:
    def __init__(self):
        """Initializes MeterPointItem"""
        pass
                          Severity: Major
                          Found in myems-api/core/meter.py and 1 other location - About 3 days to fix
                          myems-api/core/costcenter.py on lines 494..553

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 391.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 50 locations. Consider refactoring.
                          Open

                          class MeterCommandItem:
    def __init__(self):
        """Initializes Class"""
        pass
                          Severity: Major
                          Found in myems-api/core/meter.py and 49 other locations - About 3 days to fix
                          myems-api/core/combinedequipment.py on lines 713..771
                          myems-api/core/combinedequipment.py on lines 1638..1696
                          myems-api/core/combinedequipment.py on lines 1838..1896
                          myems-api/core/combinedequipment.py on lines 2037..2095
                          myems-api/core/combinedequipment.py on lines 2213..2271
                          myems-api/core/distributioncircuit.py on lines 527..585
                          myems-api/core/energystoragepowerstation.py on lines 705..763
                          myems-api/core/equipment.py on lines 1458..1515
                          myems-api/core/equipment.py on lines 1655..1713
                          myems-api/core/equipment.py on lines 1853..1911
                          myems-api/core/equipment.py on lines 2031..2088
                          myems-api/core/microgrid.py on lines 4892..4950
                          myems-api/core/sensor.py on lines 417..474
                          myems-api/core/shopfloor.py on lines 573..631
                          myems-api/core/shopfloor.py on lines 762..819
                          myems-api/core/shopfloor.py on lines 950..1008
                          myems-api/core/shopfloor.py on lines 1138..1196
                          myems-api/core/shopfloor.py on lines 1314..1371
                          myems-api/core/shopfloor.py on lines 1502..1560
                          myems-api/core/shopfloor.py on lines 1678..1736
                          myems-api/core/shopfloor.py on lines 1854..1911
                          myems-api/core/space.py on lines 932..990
                          myems-api/core/space.py on lines 1108..1166
                          myems-api/core/space.py on lines 1284..1341
                          myems-api/core/space.py on lines 1649..1707
                          myems-api/core/space.py on lines 1838..1896
                          myems-api/core/space.py on lines 2026..2084
                          myems-api/core/space.py on lines 2202..2259
                          myems-api/core/space.py on lines 2377..2434
                          myems-api/core/space.py on lines 2552..2609
                          myems-api/core/space.py on lines 2727..2784
                          myems-api/core/space.py on lines 2915..2973
                          myems-api/core/space.py on lines 3276..3334
                          myems-api/core/space.py on lines 3452..3509
                          myems-api/core/store.py on lines 705..762
                          myems-api/core/store.py on lines 893..951
                          myems-api/core/store.py on lines 1081..1139
                          myems-api/core/store.py on lines 1257..1314
                          myems-api/core/store.py on lines 1445..1503
                          myems-api/core/store.py on lines 1621..1679
                          myems-api/core/store.py on lines 1797..1854
                          myems-api/core/tenant.py on lines 805..862
                          myems-api/core/tenant.py on lines 995..1053
                          myems-api/core/tenant.py on lines 1185..1243
                          myems-api/core/tenant.py on lines 1363..1420
                          myems-api/core/tenant.py on lines 1553..1611
                          myems-api/core/tenant.py on lines 1731..1789
                          myems-api/core/tenant.py on lines 1909..1966
                          myems-api/core/virtualpowerplant.py on lines 550..608

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 388.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 2 locations. Consider refactoring.
                          Open

                              @staticmethod
    def on_get(req, resp, id_):
        if 'API-KEY' not in req.headers or \
                not isinstance(req.headers['API-KEY'], str) or \
                len(str.strip(req.headers['API-KEY'])) == 0:
                          Severity: Major
                          Found in myems-api/core/meter.py and 1 other location - About 3 days to fix
                          myems-api/core/sensor.py on lines 314..355

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 358.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Identical blocks of code found in 2 locations. Consider refactoring.
                          Open

                                          if 'id' in point and isinstance(point['id'], int):
                    cursor.execute(" SELECT name, object_type "
                                   " FROM tbl_points "
                                   " WHERE id = %s ", (point['id'],))
                    row = cursor.fetchone()
                          Severity: Major
                          Found in myems-api/core/meter.py and 1 other location - About 2 days to fix
                          myems-api/core/meter.py on lines 1768..1803

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 267.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Identical blocks of code found in 2 locations. Consider refactoring.
                          Open

                                          if 'id' in point and isinstance(point['id'], int):
                    cursor.execute(" SELECT name, object_type "
                                   " FROM tbl_points "
                                   " WHERE id = %s ", (point['id'],))
                    row = cursor.fetchone()
                          Severity: Major
                          Found in myems-api/core/meter.py and 1 other location - About 2 days to fix
                          myems-api/core/meter.py on lines 1622..1657

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 267.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Identical blocks of code found in 2 locations. Consider refactoring.
                          Open

                                          meta_result = {"id": row[0],
                               "name": row[1],
                               "uuid": row[2],
                               "energy_category": energy_category_dict.get(row[3], None),
                               "is_counted": True if row[4] else False,
                          Severity: Major
                          Found in myems-api/core/meter.py and 1 other location - About 1 day to fix
                          myems-api/core/meter.py on lines 362..377

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 143.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Identical blocks of code found in 2 locations. Consider refactoring.
                          Open

                                  if row is None:
            raise falcon.HTTPError(status=falcon.HTTP_404, title='API.NOT_FOUND',
                                   description='API.METER_NOT_FOUND')
        else:
            meta_result = {"id": row[0],
                          Severity: Major
                          Found in myems-api/core/meter.py and 1 other location - About 1 day to fix
                          myems-api/core/meter.py on lines 89..100

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 143.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 10 locations. Consider refactoring.
                          Open

                                  if master_meter_id is not None:
            cursor.execute(" SELECT name, energy_category_id "
                           " FROM tbl_meters "
                           " WHERE id = %s ",
                           (new_values['data']['master_meter_id'],))
                          Severity: Major
                          Found in myems-api/core/meter.py and 9 other locations - About 1 day to fix
                          myems-api/core/meter.py on lines 221..236
                          myems-api/core/meter.py on lines 239..254
                          myems-api/core/meter.py on lines 783..798
                          myems-api/core/offlinemeter.py on lines 187..202
                          myems-api/core/offlinemeter.py on lines 600..615
                          myems-api/core/offlinemeter.py on lines 831..846
                          myems-api/core/virtualmeter.py on lines 263..278
                          myems-api/core/virtualmeter.py on lines 778..793
                          myems-api/core/virtualmeter.py on lines 1141..1156

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 136.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 10 locations. Consider refactoring.
                          Open

                                  if master_meter_id is not None:
            cursor.execute(" SELECT name, energy_category_id "
                           " FROM tbl_meters "
                           " WHERE id = %s ",
                           (new_values['data']['master_meter_id'],))
                          Severity: Major
                          Found in myems-api/core/meter.py and 9 other locations - About 1 day to fix
                          myems-api/core/meter.py on lines 221..236
                          myems-api/core/meter.py on lines 783..798
                          myems-api/core/meter.py on lines 801..816
                          myems-api/core/offlinemeter.py on lines 187..202
                          myems-api/core/offlinemeter.py on lines 600..615
                          myems-api/core/offlinemeter.py on lines 831..846
                          myems-api/core/virtualmeter.py on lines 263..278
                          myems-api/core/virtualmeter.py on lines 778..793
                          myems-api/core/virtualmeter.py on lines 1141..1156

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 136.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 10 locations. Consider refactoring.
                          Open

                                  if energy_item_id is not None:
            cursor.execute(" SELECT name, energy_category_id "
                           " FROM tbl_energy_items "
                           " WHERE id = %s ",
                           (new_values['data']['energy_item_id'],))
                          Severity: Major
                          Found in myems-api/core/meter.py and 9 other locations - About 1 day to fix
                          myems-api/core/meter.py on lines 239..254
                          myems-api/core/meter.py on lines 783..798
                          myems-api/core/meter.py on lines 801..816
                          myems-api/core/offlinemeter.py on lines 187..202
                          myems-api/core/offlinemeter.py on lines 600..615
                          myems-api/core/offlinemeter.py on lines 831..846
                          myems-api/core/virtualmeter.py on lines 263..278
                          myems-api/core/virtualmeter.py on lines 778..793
                          myems-api/core/virtualmeter.py on lines 1141..1156

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 136.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 10 locations. Consider refactoring.
                          Open

                                  if energy_item_id is not None:
            cursor.execute(" SELECT name, energy_category_id "
                           " FROM tbl_energy_items "
                           " WHERE id = %s ",
                           (new_values['data']['energy_item_id'],))
                          Severity: Major
                          Found in myems-api/core/meter.py and 9 other locations - About 1 day to fix
                          myems-api/core/meter.py on lines 221..236
                          myems-api/core/meter.py on lines 239..254
                          myems-api/core/meter.py on lines 801..816
                          myems-api/core/offlinemeter.py on lines 187..202
                          myems-api/core/offlinemeter.py on lines 600..615
                          myems-api/core/offlinemeter.py on lines 831..846
                          myems-api/core/virtualmeter.py on lines 263..278
                          myems-api/core/virtualmeter.py on lines 778..793
                          myems-api/core/virtualmeter.py on lines 1141..1156

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 136.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 8 locations. Consider refactoring.
                          Open

                                  if 'energy_item_id' in new_values['data'].keys() and \
                new_values['data']['energy_item_id'] is not None:
            if not isinstance(new_values['data']['energy_item_id'], int) or \
                    new_values['data']['energy_item_id'] <= 0:
                raise falcon.HTTPError(status=falcon.HTTP_400, title='API.BAD_REQUEST',
                          Severity: Major
                          Found in myems-api/core/meter.py and 7 other locations - About 1 day to fix
                          myems-api/core/meter.py on lines 162..170
                          myems-api/core/offlinemeter.py on lines 149..157
                          myems-api/core/offlinemeter.py on lines 541..549
                          myems-api/core/offlinemeter.py on lines 793..801
                          myems-api/core/virtualmeter.py on lines 183..191
                          myems-api/core/virtualmeter.py on lines 689..697
                          myems-api/core/virtualmeter.py on lines 1061..1069

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 133.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 8 locations. Consider refactoring.
                          Open

                                  if 'energy_item_id' in new_values['data'].keys() and \
                new_values['data']['energy_item_id'] is not None:
            if not isinstance(new_values['data']['energy_item_id'], int) or \
                    new_values['data']['energy_item_id'] <= 0:
                raise falcon.HTTPError(status=falcon.HTTP_400, title='API.BAD_REQUEST',
                          Severity: Major
                          Found in myems-api/core/meter.py and 7 other locations - About 1 day to fix
                          myems-api/core/meter.py on lines 714..722
                          myems-api/core/offlinemeter.py on lines 149..157
                          myems-api/core/offlinemeter.py on lines 541..549
                          myems-api/core/offlinemeter.py on lines 793..801
                          myems-api/core/virtualmeter.py on lines 183..191
                          myems-api/core/virtualmeter.py on lines 689..697
                          myems-api/core/virtualmeter.py on lines 1061..1069

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 133.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 2 locations. Consider refactoring.
                          Open

                                  if energy_item_id is not None:
            cursor.execute(" SELECT name, energy_category_id "
                           " FROM tbl_energy_items "
                           " WHERE id = %s ",
                           (energy_item_id,))
                          Severity: Major
                          Found in myems-api/core/meter.py and 1 other location - About 1 day to fix
                          myems-api/core/meter.py on lines 1585..1600

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 124.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 2 locations. Consider refactoring.
                          Open

                                  if master_meter_id is not None:
            cursor.execute(" SELECT name, energy_category_id "
                           " FROM tbl_meters "
                           " WHERE id = %s ",
                           (master_meter_id,))
                          Severity: Major
                          Found in myems-api/core/meter.py and 1 other location - About 1 day to fix
                          myems-api/core/meter.py on lines 1567..1582

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 124.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 4 locations. Consider refactoring.
                          Open

                                  if 'master_meter_id' in new_values['data'].keys():
            if not isinstance(new_values['data']['master_meter_id'], int) or \
                    new_values['data']['master_meter_id'] <= 0:
                raise falcon.HTTPError(status=falcon.HTTP_400, title='API.BAD_REQUEST',
                                       description='API.INVALID_MASTER_METER_ID')
                          Severity: Major
                          Found in myems-api/core/meter.py and 3 other locations - About 7 hrs to fix
                          myems-api/core/user.py on lines 131..138
                          myems-api/core/user.py on lines 383..390
                          myems-api/core/user.py on lines 1948..1955

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 110.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 2 locations. Consider refactoring.
                          Open

                                  cursor.execute(add_values, (new_name,
                                    str(uuid.uuid4()),
                                    meta_result['energy_category_id'],
                                    meta_result['is_counted'],
                                    meta_result['hourly_low_limit'],
                          Severity: Major
                          Found in myems-api/core/meter.py and 1 other location - About 4 hrs to fix
                          myems-api/core/rule.py on lines 759..768

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 77.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 5 locations. Consider refactoring.
                          Open

                                      if rows is not None and len(rows) > 0:
                for row in rows:
                    point_result = {"id": row[0], "name": row[1]}
                    result.append(point_result)
                meta_result['points'] = result
                          Severity: Major
                          Found in myems-api/core/meter.py and 4 other locations - About 4 hrs to fix
                          myems-api/core/distributionsystem.py on lines 435..439
                          myems-api/core/meter.py on lines 1422..1426
                          myems-api/core/sensor.py on lines 522..526
                          myems-api/core/sensor.py on lines 666..670

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 74.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 5 locations. Consider refactoring.
                          Open

                                      if rows is not None and len(rows) > 0:
                for row in rows:
                    point_result = {"id": row[0], "name": row[1]}
                    result.append(point_result)
                meta_result['points'] = result
                          Severity: Major
                          Found in myems-api/core/meter.py and 4 other locations - About 4 hrs to fix
                          myems-api/core/distributionsystem.py on lines 435..439
                          myems-api/core/meter.py on lines 1738..1742
                          myems-api/core/sensor.py on lines 522..526
                          myems-api/core/sensor.py on lines 666..670

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 74.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 7 locations. Consider refactoring.
                          Open

                                  if 'hourly_high_limit' not in new_values.keys() or \
                not (isinstance(new_values['hourly_high_limit'], float) or
                     isinstance(new_values['hourly_high_limit'], int)):
            raise falcon.HTTPError(status=falcon.HTTP_400, title='API.BAD_REQUEST',
                          Severity: Major
                          Found in myems-api/core/meter.py and 6 other locations - About 3 hrs to fix
                          myems-api/core/meter.py on lines 1481..1484
                          myems-api/core/offlinemeter.py on lines 771..774
                          myems-api/core/offlinemeter.py on lines 778..781
                          myems-api/core/point.py on lines 1025..1028
                          myems-api/core/point.py on lines 1032..1035
                          myems-api/core/point.py on lines 1061..1064

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 69.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 7 locations. Consider refactoring.
                          Open

                                  if 'hourly_low_limit' not in new_values.keys() or \
                not (isinstance(new_values['hourly_low_limit'], float) or
                     isinstance(new_values['hourly_low_limit'], int)):
            raise falcon.HTTPError(status=falcon.HTTP_400, title='API.BAD_REQUEST',
                          Severity: Major
                          Found in myems-api/core/meter.py and 6 other locations - About 3 hrs to fix
                          myems-api/core/meter.py on lines 1488..1491
                          myems-api/core/offlinemeter.py on lines 771..774
                          myems-api/core/offlinemeter.py on lines 778..781
                          myems-api/core/point.py on lines 1025..1028
                          myems-api/core/point.py on lines 1032..1035
                          myems-api/core/point.py on lines 1061..1064

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 69.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 4 locations. Consider refactoring.
                          Open

                                  if row is None:
            cursor.close()
            cnx.close()
            raise falcon.HTTPError(status=falcon.HTTP_404, title='API.NOT_FOUND',
                                   description='API.METER_NOT_FOUND')
                          Severity: Major
                          Found in myems-api/core/meter.py and 3 other locations - About 2 hrs to fix
                          myems-api/core/offlinemeter.py on lines 341..347
                          myems-api/core/user.py on lines 288..294
                          myems-api/core/virtualmeter.py on lines 497..503

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 55.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 20 locations. Consider refactoring.
                          Open

                                  if 'is_counted' not in new_values.keys() or \
                not isinstance(new_values['is_counted'], bool):
            raise falcon.HTTPError(status=falcon.HTTP_400, title='API.BAD_REQUEST',
                          Severity: Major
                          Found in myems-api/core/meter.py and 19 other locations - About 2 hrs to fix
                          myems-api/core/advancedreport.py on lines 516..518
                          myems-api/core/advancedreport.py on lines 540..542
                          myems-api/core/combinedequipment.py on lines 2597..2599
                          myems-api/core/combinedequipment.py on lines 2603..2605
                          myems-api/core/equipment.py on lines 2380..2382
                          myems-api/core/equipment.py on lines 2386..2388
                          myems-api/core/offlinemeter.py on lines 765..767
                          myems-api/core/point.py on lines 1068..1070
                          myems-api/core/point.py on lines 1074..1076
                          myems-api/core/rule.py on lines 637..639
                          myems-api/core/rule.py on lines 643..645
                          myems-api/core/shopfloor.py on lines 2198..2200
                          myems-api/core/space.py on lines 3993..3995
                          myems-api/core/space.py on lines 3999..4001
                          myems-api/core/store.py on lines 2168..2170
                          myems-api/core/tenant.py on lines 2292..2294
                          myems-api/core/tenant.py on lines 2298..2300
                          myems-api/core/tenant.py on lines 2311..2313
                          myems-api/core/virtualmeter.py on lines 1048..1049

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 53.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 3 locations. Consider refactoring.
                          Open

                                  if 'points' in meta_result.keys() and \
                meta_result['points'] is not None and \
                len(meta_result['points']) > 0:
                          Severity: Major
                          Found in myems-api/core/meter.py and 2 other locations - About 1 hr to fix
                          myems-api/core/meter.py on lines 1618..1620
                          myems-api/core/sensor.py on lines 588..590

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 45.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 3 locations. Consider refactoring.
                          Open

                                  if 'points' in new_values.keys() and \
                new_values['points'] is not None and \
                len(new_values['points']) > 0:
                          Severity: Major
                          Found in myems-api/core/meter.py and 2 other locations - About 1 hr to fix
                          myems-api/core/meter.py on lines 1764..1766
                          myems-api/core/sensor.py on lines 588..590

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 45.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 41 locations. Consider refactoring.
                          Open

                                  if row_microgrid_photovoltaic is not None:
            cursor.close()
            cnx.close()
            raise falcon.HTTPError(status=falcon.HTTP_400,
                          Severity: Major
                          Found in myems-api/core/meter.py and 40 other locations - About 1 hr to fix
                          myems-api/core/combinedequipment.py on lines 1384..1387
                          myems-api/core/energyflowdiagram.py on lines 559..562
                          myems-api/core/energyflowdiagram.py on lines 871..874
                          myems-api/core/energyflowdiagram.py on lines 1214..1217
                          myems-api/core/energyflowdiagram.py on lines 1476..1479
                          myems-api/core/equipment.py on lines 1215..1218
                          myems-api/core/meter.py on lines 410..413
                          myems-api/core/meter.py on lines 546..549
                          myems-api/core/meter.py on lines 560..563
                          myems-api/core/meter.py on lines 574..577
                          myems-api/core/meter.py on lines 589..592
                          myems-api/core/meter.py on lines 605..608
                          myems-api/core/meter.py on lines 619..622
                          myems-api/core/meter.py on lines 826..829
                          myems-api/core/offlinemeter.py on lines 355..358
                          myems-api/core/point.py on lines 316..319
                          myems-api/core/point.py on lines 330..333
                          myems-api/core/point.py on lines 344..347
                          myems-api/core/point.py on lines 358..361
                          myems-api/core/point.py on lines 372..375
                          myems-api/core/point.py on lines 386..389
                          myems-api/core/point.py on lines 400..403
                          myems-api/core/point.py on lines 414..417
                          myems-api/core/point.py on lines 428..431
                          myems-api/core/point.py on lines 445..448
                          myems-api/core/point.py on lines 461..464
                          myems-api/core/point.py on lines 479..482
                          myems-api/core/point.py on lines 493..496
                          myems-api/core/point.py on lines 507..510
                          myems-api/core/point.py on lines 521..524
                          myems-api/core/point.py on lines 535..538
                          myems-api/core/point.py on lines 549..552
                          myems-api/core/point.py on lines 563..566
                          myems-api/core/point.py on lines 577..580
                          myems-api/core/point.py on lines 592..595
                          myems-api/core/point.py on lines 606..609
                          myems-api/core/point.py on lines 620..623
                          myems-api/core/point.py on lines 638..641
                          myems-api/core/user.py on lines 1102..1105
                          myems-api/core/virtualmeter.py on lines 511..514

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 43.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 41 locations. Consider refactoring.
                          Open

                                      if row is not None:
                cursor.close()
                cnx.close()
                raise falcon.HTTPError(status=falcon.HTTP_404, title='API.NOT_FOUND',
                          Severity: Major
                          Found in myems-api/core/meter.py and 40 other locations - About 1 hr to fix
                          myems-api/core/combinedequipment.py on lines 1384..1387
                          myems-api/core/energyflowdiagram.py on lines 559..562
                          myems-api/core/energyflowdiagram.py on lines 871..874
                          myems-api/core/energyflowdiagram.py on lines 1214..1217
                          myems-api/core/energyflowdiagram.py on lines 1476..1479
                          myems-api/core/equipment.py on lines 1215..1218
                          myems-api/core/meter.py on lines 410..413
                          myems-api/core/meter.py on lines 546..549
                          myems-api/core/meter.py on lines 560..563
                          myems-api/core/meter.py on lines 574..577
                          myems-api/core/meter.py on lines 589..592
                          myems-api/core/meter.py on lines 605..608
                          myems-api/core/meter.py on lines 619..622
                          myems-api/core/meter.py on lines 633..636
                          myems-api/core/offlinemeter.py on lines 355..358
                          myems-api/core/point.py on lines 316..319
                          myems-api/core/point.py on lines 330..333
                          myems-api/core/point.py on lines 344..347
                          myems-api/core/point.py on lines 358..361
                          myems-api/core/point.py on lines 372..375
                          myems-api/core/point.py on lines 386..389
                          myems-api/core/point.py on lines 400..403
                          myems-api/core/point.py on lines 414..417
                          myems-api/core/point.py on lines 428..431
                          myems-api/core/point.py on lines 445..448
                          myems-api/core/point.py on lines 461..464
                          myems-api/core/point.py on lines 479..482
                          myems-api/core/point.py on lines 493..496
                          myems-api/core/point.py on lines 507..510
                          myems-api/core/point.py on lines 521..524
                          myems-api/core/point.py on lines 535..538
                          myems-api/core/point.py on lines 549..552
                          myems-api/core/point.py on lines 563..566
                          myems-api/core/point.py on lines 577..580
                          myems-api/core/point.py on lines 592..595
                          myems-api/core/point.py on lines 606..609
                          myems-api/core/point.py on lines 620..623
                          myems-api/core/point.py on lines 638..641
                          myems-api/core/user.py on lines 1102..1105
                          myems-api/core/virtualmeter.py on lines 511..514

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 43.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 41 locations. Consider refactoring.
                          Open

                                  if row_microgrid_battery is not None:
            cursor.close()
            cnx.close()
            raise falcon.HTTPError(status=falcon.HTTP_400,
                          Severity: Major
                          Found in myems-api/core/meter.py and 40 other locations - About 1 hr to fix
                          myems-api/core/combinedequipment.py on lines 1384..1387
                          myems-api/core/energyflowdiagram.py on lines 559..562
                          myems-api/core/energyflowdiagram.py on lines 871..874
                          myems-api/core/energyflowdiagram.py on lines 1214..1217
                          myems-api/core/energyflowdiagram.py on lines 1476..1479
                          myems-api/core/equipment.py on lines 1215..1218
                          myems-api/core/meter.py on lines 410..413
                          myems-api/core/meter.py on lines 560..563
                          myems-api/core/meter.py on lines 574..577
                          myems-api/core/meter.py on lines 589..592
                          myems-api/core/meter.py on lines 605..608
                          myems-api/core/meter.py on lines 619..622
                          myems-api/core/meter.py on lines 633..636
                          myems-api/core/meter.py on lines 826..829
                          myems-api/core/offlinemeter.py on lines 355..358
                          myems-api/core/point.py on lines 316..319
                          myems-api/core/point.py on lines 330..333
                          myems-api/core/point.py on lines 344..347
                          myems-api/core/point.py on lines 358..361
                          myems-api/core/point.py on lines 372..375
                          myems-api/core/point.py on lines 386..389
                          myems-api/core/point.py on lines 400..403
                          myems-api/core/point.py on lines 414..417
                          myems-api/core/point.py on lines 428..431
                          myems-api/core/point.py on lines 445..448
                          myems-api/core/point.py on lines 461..464
                          myems-api/core/point.py on lines 479..482
                          myems-api/core/point.py on lines 493..496
                          myems-api/core/point.py on lines 507..510
                          myems-api/core/point.py on lines 521..524
                          myems-api/core/point.py on lines 535..538
                          myems-api/core/point.py on lines 549..552
                          myems-api/core/point.py on lines 563..566
                          myems-api/core/point.py on lines 577..580
                          myems-api/core/point.py on lines 592..595
                          myems-api/core/point.py on lines 606..609
                          myems-api/core/point.py on lines 620..623
                          myems-api/core/point.py on lines 638..641
                          myems-api/core/user.py on lines 1102..1105
                          myems-api/core/virtualmeter.py on lines 511..514

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 43.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 41 locations. Consider refactoring.
                          Open

                                  if row_microgrid_evcharger is not None:
            cursor.close()
            cnx.close()
            raise falcon.HTTPError(status=falcon.HTTP_400,
                          Severity: Major
                          Found in myems-api/core/meter.py and 40 other locations - About 1 hr to fix
                          myems-api/core/combinedequipment.py on lines 1384..1387
                          myems-api/core/energyflowdiagram.py on lines 559..562
                          myems-api/core/energyflowdiagram.py on lines 871..874
                          myems-api/core/energyflowdiagram.py on lines 1214..1217
                          myems-api/core/energyflowdiagram.py on lines 1476..1479
                          myems-api/core/equipment.py on lines 1215..1218
                          myems-api/core/meter.py on lines 410..413
                          myems-api/core/meter.py on lines 546..549
                          myems-api/core/meter.py on lines 574..577
                          myems-api/core/meter.py on lines 589..592
                          myems-api/core/meter.py on lines 605..608
                          myems-api/core/meter.py on lines 619..622
                          myems-api/core/meter.py on lines 633..636
                          myems-api/core/meter.py on lines 826..829
                          myems-api/core/offlinemeter.py on lines 355..358
                          myems-api/core/point.py on lines 316..319
                          myems-api/core/point.py on lines 330..333
                          myems-api/core/point.py on lines 344..347
                          myems-api/core/point.py on lines 358..361
                          myems-api/core/point.py on lines 372..375
                          myems-api/core/point.py on lines 386..389
                          myems-api/core/point.py on lines 400..403
                          myems-api/core/point.py on lines 414..417
                          myems-api/core/point.py on lines 428..431
                          myems-api/core/point.py on lines 445..448
                          myems-api/core/point.py on lines 461..464
                          myems-api/core/point.py on lines 479..482
                          myems-api/core/point.py on lines 493..496
                          myems-api/core/point.py on lines 507..510
                          myems-api/core/point.py on lines 521..524
                          myems-api/core/point.py on lines 535..538
                          myems-api/core/point.py on lines 549..552
                          myems-api/core/point.py on lines 563..566
                          myems-api/core/point.py on lines 577..580
                          myems-api/core/point.py on lines 592..595
                          myems-api/core/point.py on lines 606..609
                          myems-api/core/point.py on lines 620..623
                          myems-api/core/point.py on lines 638..641
                          myems-api/core/user.py on lines 1102..1105
                          myems-api/core/virtualmeter.py on lines 511..514

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 43.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 41 locations. Consider refactoring.
                          Open

                                  if row_microgrid_heatpump is not None:
            cursor.close()
            cnx.close()
            raise falcon.HTTPError(status=falcon.HTTP_400,
                          Severity: Major
                          Found in myems-api/core/meter.py and 40 other locations - About 1 hr to fix
                          myems-api/core/combinedequipment.py on lines 1384..1387
                          myems-api/core/energyflowdiagram.py on lines 559..562
                          myems-api/core/energyflowdiagram.py on lines 871..874
                          myems-api/core/energyflowdiagram.py on lines 1214..1217
                          myems-api/core/energyflowdiagram.py on lines 1476..1479
                          myems-api/core/equipment.py on lines 1215..1218
                          myems-api/core/meter.py on lines 410..413
                          myems-api/core/meter.py on lines 546..549
                          myems-api/core/meter.py on lines 560..563
                          myems-api/core/meter.py on lines 574..577
                          myems-api/core/meter.py on lines 589..592
                          myems-api/core/meter.py on lines 619..622
                          myems-api/core/meter.py on lines 633..636
                          myems-api/core/meter.py on lines 826..829
                          myems-api/core/offlinemeter.py on lines 355..358
                          myems-api/core/point.py on lines 316..319
                          myems-api/core/point.py on lines 330..333
                          myems-api/core/point.py on lines 344..347
                          myems-api/core/point.py on lines 358..361
                          myems-api/core/point.py on lines 372..375
                          myems-api/core/point.py on lines 386..389
                          myems-api/core/point.py on lines 400..403
                          myems-api/core/point.py on lines 414..417
                          myems-api/core/point.py on lines 428..431
                          myems-api/core/point.py on lines 445..448
                          myems-api/core/point.py on lines 461..464
                          myems-api/core/point.py on lines 479..482
                          myems-api/core/point.py on lines 493..496
                          myems-api/core/point.py on lines 507..510
                          myems-api/core/point.py on lines 521..524
                          myems-api/core/point.py on lines 535..538
                          myems-api/core/point.py on lines 549..552
                          myems-api/core/point.py on lines 563..566
                          myems-api/core/point.py on lines 577..580
                          myems-api/core/point.py on lines 592..595
                          myems-api/core/point.py on lines 606..609
                          myems-api/core/point.py on lines 620..623
                          myems-api/core/point.py on lines 638..641
                          myems-api/core/user.py on lines 1102..1105
                          myems-api/core/virtualmeter.py on lines 511..514

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 43.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 41 locations. Consider refactoring.
                          Open

                                  if row_microgrid_load is not None:
            cursor.close()
            cnx.close()
            raise falcon.HTTPError(status=falcon.HTTP_400,
                          Severity: Major
                          Found in myems-api/core/meter.py and 40 other locations - About 1 hr to fix
                          myems-api/core/combinedequipment.py on lines 1384..1387
                          myems-api/core/energyflowdiagram.py on lines 559..562
                          myems-api/core/energyflowdiagram.py on lines 871..874
                          myems-api/core/energyflowdiagram.py on lines 1214..1217
                          myems-api/core/energyflowdiagram.py on lines 1476..1479
                          myems-api/core/equipment.py on lines 1215..1218
                          myems-api/core/meter.py on lines 410..413
                          myems-api/core/meter.py on lines 546..549
                          myems-api/core/meter.py on lines 560..563
                          myems-api/core/meter.py on lines 574..577
                          myems-api/core/meter.py on lines 589..592
                          myems-api/core/meter.py on lines 605..608
                          myems-api/core/meter.py on lines 633..636
                          myems-api/core/meter.py on lines 826..829
                          myems-api/core/offlinemeter.py on lines 355..358
                          myems-api/core/point.py on lines 316..319
                          myems-api/core/point.py on lines 330..333
                          myems-api/core/point.py on lines 344..347
                          myems-api/core/point.py on lines 358..361
                          myems-api/core/point.py on lines 372..375
                          myems-api/core/point.py on lines 386..389
                          myems-api/core/point.py on lines 400..403
                          myems-api/core/point.py on lines 414..417
                          myems-api/core/point.py on lines 428..431
                          myems-api/core/point.py on lines 445..448
                          myems-api/core/point.py on lines 461..464
                          myems-api/core/point.py on lines 479..482
                          myems-api/core/point.py on lines 493..496
                          myems-api/core/point.py on lines 507..510
                          myems-api/core/point.py on lines 521..524
                          myems-api/core/point.py on lines 535..538
                          myems-api/core/point.py on lines 549..552
                          myems-api/core/point.py on lines 563..566
                          myems-api/core/point.py on lines 577..580
                          myems-api/core/point.py on lines 592..595
                          myems-api/core/point.py on lines 606..609
                          myems-api/core/point.py on lines 620..623
                          myems-api/core/point.py on lines 638..641
                          myems-api/core/user.py on lines 1102..1105
                          myems-api/core/virtualmeter.py on lines 511..514

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 43.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 41 locations. Consider refactoring.
                          Open

                                  if row_virtual_meter is not None:
            cursor.close()
            cnx.close()
            raise falcon.HTTPError(status=falcon.HTTP_400,
                          Severity: Major
                          Found in myems-api/core/meter.py and 40 other locations - About 1 hr to fix
                          myems-api/core/combinedequipment.py on lines 1384..1387
                          myems-api/core/energyflowdiagram.py on lines 559..562
                          myems-api/core/energyflowdiagram.py on lines 871..874
                          myems-api/core/energyflowdiagram.py on lines 1214..1217
                          myems-api/core/energyflowdiagram.py on lines 1476..1479
                          myems-api/core/equipment.py on lines 1215..1218
                          myems-api/core/meter.py on lines 546..549
                          myems-api/core/meter.py on lines 560..563
                          myems-api/core/meter.py on lines 574..577
                          myems-api/core/meter.py on lines 589..592
                          myems-api/core/meter.py on lines 605..608
                          myems-api/core/meter.py on lines 619..622
                          myems-api/core/meter.py on lines 633..636
                          myems-api/core/meter.py on lines 826..829
                          myems-api/core/offlinemeter.py on lines 355..358
                          myems-api/core/point.py on lines 316..319
                          myems-api/core/point.py on lines 330..333
                          myems-api/core/point.py on lines 344..347
                          myems-api/core/point.py on lines 358..361
                          myems-api/core/point.py on lines 372..375
                          myems-api/core/point.py on lines 386..389
                          myems-api/core/point.py on lines 400..403
                          myems-api/core/point.py on lines 414..417
                          myems-api/core/point.py on lines 428..431
                          myems-api/core/point.py on lines 445..448
                          myems-api/core/point.py on lines 461..464
                          myems-api/core/point.py on lines 479..482
                          myems-api/core/point.py on lines 493..496
                          myems-api/core/point.py on lines 507..510
                          myems-api/core/point.py on lines 521..524
                          myems-api/core/point.py on lines 535..538
                          myems-api/core/point.py on lines 549..552
                          myems-api/core/point.py on lines 563..566
                          myems-api/core/point.py on lines 577..580
                          myems-api/core/point.py on lines 592..595
                          myems-api/core/point.py on lines 606..609
                          myems-api/core/point.py on lines 620..623
                          myems-api/core/point.py on lines 638..641
                          myems-api/core/user.py on lines 1102..1105
                          myems-api/core/virtualmeter.py on lines 511..514

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 43.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 41 locations. Consider refactoring.
                          Open

                                  if row_microgrid_generators is not None:
            cursor.close()
            cnx.close()
            raise falcon.HTTPError(status=falcon.HTTP_400,
                          Severity: Major
                          Found in myems-api/core/meter.py and 40 other locations - About 1 hr to fix
                          myems-api/core/combinedequipment.py on lines 1384..1387
                          myems-api/core/energyflowdiagram.py on lines 559..562
                          myems-api/core/energyflowdiagram.py on lines 871..874
                          myems-api/core/energyflowdiagram.py on lines 1214..1217
                          myems-api/core/energyflowdiagram.py on lines 1476..1479
                          myems-api/core/equipment.py on lines 1215..1218
                          myems-api/core/meter.py on lines 410..413
                          myems-api/core/meter.py on lines 546..549
                          myems-api/core/meter.py on lines 560..563
                          myems-api/core/meter.py on lines 589..592
                          myems-api/core/meter.py on lines 605..608
                          myems-api/core/meter.py on lines 619..622
                          myems-api/core/meter.py on lines 633..636
                          myems-api/core/meter.py on lines 826..829
                          myems-api/core/offlinemeter.py on lines 355..358
                          myems-api/core/point.py on lines 316..319
                          myems-api/core/point.py on lines 330..333
                          myems-api/core/point.py on lines 344..347
                          myems-api/core/point.py on lines 358..361
                          myems-api/core/point.py on lines 372..375
                          myems-api/core/point.py on lines 386..389
                          myems-api/core/point.py on lines 400..403
                          myems-api/core/point.py on lines 414..417
                          myems-api/core/point.py on lines 428..431
                          myems-api/core/point.py on lines 445..448
                          myems-api/core/point.py on lines 461..464
                          myems-api/core/point.py on lines 479..482
                          myems-api/core/point.py on lines 493..496
                          myems-api/core/point.py on lines 507..510
                          myems-api/core/point.py on lines 521..524
                          myems-api/core/point.py on lines 535..538
                          myems-api/core/point.py on lines 549..552
                          myems-api/core/point.py on lines 563..566
                          myems-api/core/point.py on lines 577..580
                          myems-api/core/point.py on lines 592..595
                          myems-api/core/point.py on lines 606..609
                          myems-api/core/point.py on lines 620..623
                          myems-api/core/point.py on lines 638..641
                          myems-api/core/user.py on lines 1102..1105
                          myems-api/core/virtualmeter.py on lines 511..514

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 43.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          Similar blocks of code found in 41 locations. Consider refactoring.
                          Open

                                  if row_microgrid_grid is not None:
            cursor.close()
            cnx.close()
            raise falcon.HTTPError(status=falcon.HTTP_400,
                          Severity: Major
                          Found in myems-api/core/meter.py and 40 other locations - About 1 hr to fix
                          myems-api/core/combinedequipment.py on lines 1384..1387
                          myems-api/core/energyflowdiagram.py on lines 559..562
                          myems-api/core/energyflowdiagram.py on lines 871..874
                          myems-api/core/energyflowdiagram.py on lines 1214..1217
                          myems-api/core/energyflowdiagram.py on lines 1476..1479
                          myems-api/core/equipment.py on lines 1215..1218
                          myems-api/core/meter.py on lines 410..413
                          myems-api/core/meter.py on lines 546..549
                          myems-api/core/meter.py on lines 560..563
                          myems-api/core/meter.py on lines 574..577
                          myems-api/core/meter.py on lines 605..608
                          myems-api/core/meter.py on lines 619..622
                          myems-api/core/meter.py on lines 633..636
                          myems-api/core/meter.py on lines 826..829
                          myems-api/core/offlinemeter.py on lines 355..358
                          myems-api/core/point.py on lines 316..319
                          myems-api/core/point.py on lines 330..333
                          myems-api/core/point.py on lines 344..347
                          myems-api/core/point.py on lines 358..361
                          myems-api/core/point.py on lines 372..375
                          myems-api/core/point.py on lines 386..389
                          myems-api/core/point.py on lines 400..403
                          myems-api/core/point.py on lines 414..417
                          myems-api/core/point.py on lines 428..431
                          myems-api/core/point.py on lines 445..448
                          myems-api/core/point.py on lines 461..464
                          myems-api/core/point.py on lines 479..482
                          myems-api/core/point.py on lines 493..496
                          myems-api/core/point.py on lines 507..510
                          myems-api/core/point.py on lines 521..524
                          myems-api/core/point.py on lines 535..538
                          myems-api/core/point.py on lines 549..552
                          myems-api/core/point.py on lines 563..566
                          myems-api/core/point.py on lines 577..580
                          myems-api/core/point.py on lines 592..595
                          myems-api/core/point.py on lines 606..609
                          myems-api/core/point.py on lines 620..623
                          myems-api/core/point.py on lines 638..641
                          myems-api/core/user.py on lines 1102..1105
                          myems-api/core/virtualmeter.py on lines 511..514

                          Duplicated Code

                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                          Tuning

                          This issue has a mass of 43.

                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                          Refactorings

                          Further Reading

                          There are no issues that match your filters.

                          Category
                          Status