reports.tenantbill.Reporting.__init__() - Code Metrics - Inspection of "Merge branch 'develop'" - myems/myems-api - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( dc4cf6...d9c3b0 )

by Guangyu

created 2021-01-06 13:56 UTC

reports.tenantbill.Reporting.init() A

↳ Parent: reports.tenantbill

Complexity

Conditions

Size

Total Lines	3
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	3
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0

import falcon
import simplejson as json
import mysql.connector
import config
from datetime import datetime, timedelta, timezone
import utilities
from decimal import *


class Reporting:
    @staticmethod
    def __init__():
        pass

    @staticmethod
    def on_options(req, resp):
        resp.status = falcon.HTTP_200

    ####################################################################################################################
    # PROCEDURES
    # Step 1: valid parameters
    # Step 2: query the tenant
    # Step 3: query energy categories
    # Step 4: query reporting period energy input
    # Step 5: query reporting period energy cost
    # Step 6: query tariff data
    # Step 7: construct the report
    ####################################################################################################################
    @staticmethod
    def on_get(req, resp):
        print(req.params)
        tenant_id = req.params.get('tenantid')
        reporting_start_datetime_local = req.params.get('reportingperiodstartdatetime')
        reporting_end_datetime_local = req.params.get('reportingperiodenddatetime')

        period_type = 'daily'

        ################################################################################################################
        # Step 1: valid parameters
        ################################################################################################################
        if tenant_id is None:
            raise falcon.HTTPError(falcon.HTTP_400, title='API.BAD_REQUEST', description='API.INVALID_TENANT_ID')
        else:
            tenant_id = str.strip(tenant_id)
            if not tenant_id.isdigit() or int(tenant_id) <= 0:
                raise falcon.HTTPError(falcon.HTTP_400, title='API.BAD_REQUEST', description='API.INVALID_TENANT_ID')

        timezone_offset = int(config.utc_offset[1:3]) * 60 + int(config.utc_offset[4:6])
        if config.utc_offset[0] == '-':
            timezone_offset = -timezone_offset

        if reporting_start_datetime_local is None:
            raise falcon.HTTPError(falcon.HTTP_400, title='API.BAD_REQUEST',
                                   description="API.INVALID_REPORTING_PERIOD_BEGINS_DATETIME")
        else:
            reporting_start_datetime_local = str.strip(reporting_start_datetime_local)
            try:
                reporting_start_datetime_utc = datetime.strptime(reporting_start_datetime_local,
                                                                 '%Y-%m-%dT%H:%M:%S').replace(tzinfo=timezone.utc) - \
                    timedelta(minutes=timezone_offset)
            except ValueError:
                raise falcon.HTTPError(falcon.HTTP_400, title='API.BAD_REQUEST',
                                       description="API.INVALID_REPORTING_PERIOD_BEGINS_DATETIME")

        if reporting_end_datetime_local is None:
            raise falcon.HTTPError(falcon.HTTP_400, title='API.BAD_REQUEST',
                                   description="API.INVALID_REPORTING_PERIOD_ENDS_DATETIME")
        else:
            reporting_end_datetime_local = str.strip(reporting_end_datetime_local)
            try:
                reporting_end_datetime_utc = datetime.strptime(reporting_end_datetime_local,
                                                               '%Y-%m-%dT%H:%M:%S').replace(tzinfo=timezone.utc) - \
                    timedelta(minutes=timezone_offset)
            except ValueError:
                raise falcon.HTTPError(falcon.HTTP_400, title='API.BAD_REQUEST',
                                       description="API.INVALID_REPORTING_PERIOD_ENDS_DATETIME")

        if reporting_start_datetime_utc >= reporting_end_datetime_utc:
            raise falcon.HTTPError(falcon.HTTP_400, title='API.BAD_REQUEST',
                                   description='API.INVALID_REPORTING_PERIOD_ENDS_DATETIME')

        ################################################################################################################
        # Step 2: query the tenant
        ################################################################################################################
        cnx_system = mysql.connector.connect(**config.myems_system_db)
        cursor_system = cnx_system.cursor()

        cnx_energy = mysql.connector.connect(**config.myems_energy_db)
        cursor_energy = cnx_energy.cursor()

        cnx_billing = mysql.connector.connect(**config.myems_billing_db)
        cursor_billing = cnx_billing.cursor()

        cursor_system.execute(" SELECT t.id, t.name, t.buildings, t.floors, t.rooms, t.lease_number, "
                              "        c.email, c.phone, cost_center_id "
                              " FROM tbl_tenants t, tbl_contacts c "
                              " WHERE t.id = %s AND t.contact_id = c.id ", (tenant_id,))
        row_tenant = cursor_system.fetchone()
        if row_tenant is None:
            if cursor_system:
                cursor_system.close()
            if cnx_system:
                cnx_system.disconnect()

            if cursor_energy:
                cursor_energy.close()
            if cnx_energy:
                cnx_energy.disconnect()

            if cursor_billing:
                cursor_billing.close()
            if cnx_billing:
                cnx_billing.disconnect()

            raise falcon.HTTPError(falcon.HTTP_404, title='API.NOT_FOUND', description='API.TENANT_NOT_FOUND')

        tenant = dict()
        tenant['id'] = row_tenant[0]
        tenant['name'] = row_tenant[1]
        tenant['buildings'] = row_tenant[2]
        tenant['floors'] = row_tenant[3]
        tenant['rooms'] = row_tenant[4]
        tenant['lease_number'] = row_tenant[5]
        tenant['email'] = row_tenant[6]
        tenant['phone'] = row_tenant[7]
        tenant['cost_center_id'] = row_tenant[8]

        ################################################################################################################
        # Step 3: query energy categories
        ################################################################################################################
        energy_category_set = set()

        # query energy categories in reporting period
        cursor_billing.execute(" SELECT DISTINCT(energy_category_id) "
                               " FROM tbl_tenant_input_category_hourly "
                               " WHERE tenant_id = %s "
                               "     AND start_datetime_utc >= %s "
                               "     AND start_datetime_utc < %s ",
                               (tenant['id'], reporting_start_datetime_utc, reporting_end_datetime_utc))
        rows_energy_categories = cursor_billing.fetchall()
        if rows_energy_categories is not None or len(rows_energy_categories) > 0:
            for row_energy_category in rows_energy_categories:
                energy_category_set.add(row_energy_category[0])

        # query all energy categories
        cursor_system.execute(" SELECT id, name, unit_of_measure, kgce, kgco2e "
                              " FROM tbl_energy_categories "
                              " ORDER BY id ", )
        rows_energy_categories = cursor_system.fetchall()
        if rows_energy_categories is None or len(rows_energy_categories) == 0:

            if cursor_system:
                cursor_system.close()
            if cnx_system:
                cnx_system.disconnect()

            if cursor_energy:
                cursor_energy.close()
            if cnx_energy:
                cnx_energy.disconnect()

            if cursor_billing:
                cursor_billing.close()
            if cnx_billing:
                cnx_billing.disconnect()

            raise falcon.HTTPError(falcon.HTTP_404,
                                   title='API.NOT_FOUND',
                                   description='API.ENERGY_CATEGORY_NOT_FOUND')
        energy_category_dict = dict()
        for row_energy_category in rows_energy_categories:
            if row_energy_category[0] in energy_category_set:
                energy_category_dict[row_energy_category[0]] = {"name": row_energy_category[1],
                                                                "unit_of_measure": row_energy_category[2],
                                                                "kgce": row_energy_category[3],
                                                                "kgco2e": row_energy_category[4]}

        ################################################################################################################
        # Step 4: query reporting period energy input
        ################################################################################################################
        reporting_input = dict()
        if energy_category_set is not None and len(energy_category_set) > 0:
            for energy_category_id in energy_category_set:
                reporting_input[energy_category_id] = dict()
                reporting_input[energy_category_id]['timestamps'] = list()
                reporting_input[energy_category_id]['values'] = list()
                reporting_input[energy_category_id]['subtotal'] = Decimal(0.0)

                cursor_energy.execute(" SELECT start_datetime_utc, actual_value "
                                      " FROM tbl_tenant_input_category_hourly "
                                      " WHERE tenant_id = %s "
                                      "     AND energy_category_id = %s "
                                      "     AND start_datetime_utc >= %s "
                                      "     AND start_datetime_utc < %s "
                                      " ORDER BY start_datetime_utc ",
                                      (tenant['id'],
                                       energy_category_id,
                                       reporting_start_datetime_utc,
                                       reporting_end_datetime_utc))
                rows_tenant_hourly = cursor_energy.fetchall()

                rows_tenant_periodically = utilities.aggregate_hourly_data_by_period(rows_tenant_hourly,
                                                                                     reporting_start_datetime_utc,
                                                                                     reporting_end_datetime_utc,
                                                                                     period_type)
                for row_tenant_periodically in rows_tenant_periodically:
                    current_datetime_local = row_tenant_periodically[0].replace(tzinfo=timezone.utc) + \
                                             timedelta(minutes=timezone_offset)
                    if period_type == 'hourly':
                        current_datetime = current_datetime_local.strftime('%Y-%m-%dT%H:%M:%S')
                    elif period_type == 'daily':
                        current_datetime = current_datetime_local.strftime('%Y-%m-%d')
                    elif period_type == 'monthly':
                        current_datetime = current_datetime_local.strftime('%Y-%m')
                    elif period_type == 'yearly':
                        current_datetime = current_datetime_local.strftime('%Y')

                    actual_value = Decimal(0.0) if row_tenant_periodically[1] is None else row_tenant_periodically[1]
                    reporting_input[energy_category_id]['timestamps'].append(current_datetime)

                    reporting_input[energy_category_id]['values'].append(actual_value)
                    reporting_input[energy_category_id]['subtotal'] += actual_value

        ################################################################################################################
        # Step 5: query reporting period energy cost
        ################################################################################################################
        reporting_cost = dict()
        if energy_category_set is not None and len(energy_category_set) > 0:
            for energy_category_id in energy_category_set:
                reporting_cost[energy_category_id] = dict()
                reporting_cost[energy_category_id]['timestamps'] = list()
                reporting_cost[energy_category_id]['values'] = list()
                reporting_cost[energy_category_id]['subtotal'] = Decimal(0.0)

                cursor_billing.execute(" SELECT start_datetime_utc, actual_value "
                                       " FROM tbl_tenant_input_category_hourly "
                                       " WHERE tenant_id = %s "
                                       "     AND energy_category_id = %s "
                                       "     AND start_datetime_utc >= %s "
                                       "     AND start_datetime_utc < %s "
                                       " ORDER BY start_datetime_utc ",
                                       (tenant['id'],
                                        energy_category_id,
                                        reporting_start_datetime_utc,
                                        reporting_end_datetime_utc))
                rows_tenant_hourly = cursor_billing.fetchall()

                rows_tenant_periodically = utilities.aggregate_hourly_data_by_period(rows_tenant_hourly,
                                                                                     reporting_start_datetime_utc,
                                                                                     reporting_end_datetime_utc,
                                                                                     period_type)
                for row_tenant_periodically in rows_tenant_periodically:
                    current_datetime_local = row_tenant_periodically[0].replace(tzinfo=timezone.utc) + \
                                             timedelta(minutes=timezone_offset)
                    if period_type == 'hourly':
                        current_datetime = current_datetime_local.strftime('%Y-%m-%dT%H:%M:%S')
                    elif period_type == 'daily':
                        current_datetime = current_datetime_local.strftime('%Y-%m-%d')
                    elif period_type == 'monthly':
                        current_datetime = current_datetime_local.strftime('%Y-%m')
                    elif period_type == 'yearly':
                        current_datetime = current_datetime_local.strftime('%Y')

                    actual_value = Decimal(0.0) if row_tenant_periodically[1] is None else row_tenant_periodically[1]
                    reporting_cost[energy_category_id]['timestamps'].append(current_datetime)
                    reporting_cost[energy_category_id]['values'].append(actual_value)
                    reporting_cost[energy_category_id]['subtotal'] += actual_value

        ################################################################################################################
        # Step 6: query tariff data
        ################################################################################################################
        parameters_data = dict()
        parameters_data['names'] = list()
        parameters_data['timestamps'] = list()
        parameters_data['values'] = list()
        if energy_category_set is not None and len(energy_category_set) > 0:
            for energy_category_id in energy_category_set:
                energy_category_tariff_dict = utilities.get_energy_category_tariffs(tenant['cost_center_id'],
                                                                                    energy_category_id,
                                                                                    reporting_start_datetime_utc,
                                                                                    reporting_end_datetime_utc)
                tariff_timestamp_list = list()
                tariff_value_list = list()
                for k, v in energy_category_tariff_dict.items():
                    # convert k from utc to local
                    k = k + timedelta(minutes=timezone_offset)
                    tariff_timestamp_list.append(k.isoformat()[0:19][0:19])
                    tariff_value_list.append(v)

                parameters_data['names'].append('TARIFF-' + energy_category_dict[energy_category_id]['name'])
                parameters_data['timestamps'].append(tariff_timestamp_list)
                parameters_data['values'].append(tariff_value_list)

        ################################################################################################################
        # Step 7: construct the report
        ################################################################################################################
        if cursor_system:
            cursor_system.close()
        if cnx_system:
            cnx_system.disconnect()

        if cursor_energy:
            cursor_energy.close()
        if cnx_energy:
            cnx_energy.disconnect()

        if cursor_billing:
            cursor_billing.close()
        if cnx_billing:
            cnx_billing.disconnect()

        result = dict()

        result['tenant'] = dict()
        result['tenant']['name'] = tenant['name']
        result['tenant']['buildings'] = tenant['buildings']
        result['tenant']['floors'] = tenant['floors']
        result['tenant']['rooms'] = tenant['rooms']
        result['tenant']['lease_number'] = tenant['lease_number']
        result['tenant']['email'] = tenant['email']
        result['tenant']['phone'] = tenant['phone']

        result['reporting_period'] = dict()
        result['reporting_period']['names'] = list()
        result['reporting_period']['energy_category_ids'] = list()
        result['reporting_period']['units'] = list()
        result['reporting_period']['subtotals_input'] = list()
        result['reporting_period']['subtotals_cost'] = list()
        result['reporting_period']['total_cost'] = Decimal(0.0)
        result['reporting_period']['currency_unit'] = config.currency_unit

        if energy_category_set is not None and len(energy_category_set) > 0:
            for energy_category_id in energy_category_set:
                result['reporting_period']['names'].append(energy_category_dict[energy_category_id]['name'])
                result['reporting_period']['energy_category_ids'].append(energy_category_id)
                result['reporting_period']['units'].append(energy_category_dict[energy_category_id]['unit_of_measure'])
                result['reporting_period']['subtotals_input'].append(reporting_input[energy_category_id]['subtotal'])
                result['reporting_period']['subtotals_cost'].append(reporting_cost[energy_category_id]['subtotal'])
                result['reporting_period']['total_cost'] += reporting_cost[energy_category_id]['subtotal']

        result['parameters'] = {
            "names": parameters_data['names'],
            "timestamps": parameters_data['timestamps'],
            "values": parameters_data['values']
        }

        resp.body = json.dumps(result)


1		import falcon
2		import simplejson as json
3		import mysql.connector
4		import config
5		from datetime import datetime, timedelta, timezone
6		import utilities
7		from decimal import *
8
9
10		class Reporting:
11		@staticmethod
12		def __init__():
13		pass
14
15		@staticmethod
16		def on_options(req, resp):
17		resp.status = falcon.HTTP_200
18
19		####################################################################################################################
20		# PROCEDURES
21		# Step 1: valid parameters
22		# Step 2: query the tenant
23		# Step 3: query energy categories
24		# Step 4: query reporting period energy input
25		# Step 5: query reporting period energy cost
26		# Step 6: query tariff data
27		# Step 7: construct the report
28		####################################################################################################################
29		@staticmethod
30		def on_get(req, resp):
31		print(req.params)
32		tenant_id = req.params.get('tenantid')
33		reporting_start_datetime_local = req.params.get('reportingperiodstartdatetime')
34		reporting_end_datetime_local = req.params.get('reportingperiodenddatetime')
35
36		period_type = 'daily'
37
38		################################################################################################################
39		# Step 1: valid parameters
40		################################################################################################################
41		if tenant_id is None:
42		raise falcon.HTTPError(falcon.HTTP_400, title='API.BAD_REQUEST', description='API.INVALID_TENANT_ID')
43		else:
44		tenant_id = str.strip(tenant_id)
45		if not tenant_id.isdigit() or int(tenant_id) <= 0:
46		raise falcon.HTTPError(falcon.HTTP_400, title='API.BAD_REQUEST', description='API.INVALID_TENANT_ID')
47
48		timezone_offset = int(config.utc_offset[1:3]) * 60 + int(config.utc_offset[4:6])
49		if config.utc_offset[0] == '-':
50		timezone_offset = -timezone_offset
51
52		if reporting_start_datetime_local is None:
53		raise falcon.HTTPError(falcon.HTTP_400, title='API.BAD_REQUEST',
54		description="API.INVALID_REPORTING_PERIOD_BEGINS_DATETIME")
55		else:
56		reporting_start_datetime_local = str.strip(reporting_start_datetime_local)
57		try:
58		reporting_start_datetime_utc = datetime.strptime(reporting_start_datetime_local,
59		'%Y-%m-%dT%H:%M:%S').replace(tzinfo=timezone.utc) - \
60		timedelta(minutes=timezone_offset)
61		except ValueError:
62		raise falcon.HTTPError(falcon.HTTP_400, title='API.BAD_REQUEST',
63		description="API.INVALID_REPORTING_PERIOD_BEGINS_DATETIME")
64
65		if reporting_end_datetime_local is None:
66		raise falcon.HTTPError(falcon.HTTP_400, title='API.BAD_REQUEST',
67		description="API.INVALID_REPORTING_PERIOD_ENDS_DATETIME")
68		else:
69		reporting_end_datetime_local = str.strip(reporting_end_datetime_local)
70		try:
71		reporting_end_datetime_utc = datetime.strptime(reporting_end_datetime_local,
72		'%Y-%m-%dT%H:%M:%S').replace(tzinfo=timezone.utc) - \
73		timedelta(minutes=timezone_offset)
74		except ValueError:
75		raise falcon.HTTPError(falcon.HTTP_400, title='API.BAD_REQUEST',
76		description="API.INVALID_REPORTING_PERIOD_ENDS_DATETIME")
77
78		if reporting_start_datetime_utc >= reporting_end_datetime_utc:
79		raise falcon.HTTPError(falcon.HTTP_400, title='API.BAD_REQUEST',
80		description='API.INVALID_REPORTING_PERIOD_ENDS_DATETIME')
81
82		################################################################################################################
83		# Step 2: query the tenant
84		################################################################################################################
85		cnx_system = mysql.connector.connect(**config.myems_system_db)
86		cursor_system = cnx_system.cursor()
87
88		cnx_energy = mysql.connector.connect(**config.myems_energy_db)
89		cursor_energy = cnx_energy.cursor()
90
91		cnx_billing = mysql.connector.connect(**config.myems_billing_db)
92		cursor_billing = cnx_billing.cursor()
93
94		cursor_system.execute(" SELECT t.id, t.name, t.buildings, t.floors, t.rooms, t.lease_number, "
95		" c.email, c.phone, cost_center_id "
96		" FROM tbl_tenants t, tbl_contacts c "
97		" WHERE t.id = %s AND t.contact_id = c.id ", (tenant_id,))
98		row_tenant = cursor_system.fetchone()
99		if row_tenant is None:
100		if cursor_system:
101		cursor_system.close()
102		if cnx_system:
103		cnx_system.disconnect()
104
105		if cursor_energy:
106		cursor_energy.close()
107		if cnx_energy:
108		cnx_energy.disconnect()
109
110		if cursor_billing:
111		cursor_billing.close()
112		if cnx_billing:
113		cnx_billing.disconnect()
114
115		raise falcon.HTTPError(falcon.HTTP_404, title='API.NOT_FOUND', description='API.TENANT_NOT_FOUND')
116
117		tenant = dict()
118		tenant['id'] = row_tenant[0]
119		tenant['name'] = row_tenant[1]
120		tenant['buildings'] = row_tenant[2]
121		tenant['floors'] = row_tenant[3]
122		tenant['rooms'] = row_tenant[4]
123		tenant['lease_number'] = row_tenant[5]
124		tenant['email'] = row_tenant[6]
125		tenant['phone'] = row_tenant[7]
126		tenant['cost_center_id'] = row_tenant[8]
127
128		################################################################################################################
129		# Step 3: query energy categories
130		################################################################################################################
131		energy_category_set = set()
132
133		# query energy categories in reporting period
134		cursor_billing.execute(" SELECT DISTINCT(energy_category_id) "
135		" FROM tbl_tenant_input_category_hourly "
136		" WHERE tenant_id = %s "
137		" AND start_datetime_utc >= %s "
138		" AND start_datetime_utc < %s ",
139		(tenant['id'], reporting_start_datetime_utc, reporting_end_datetime_utc))
140		rows_energy_categories = cursor_billing.fetchall()
141		if rows_energy_categories is not None or len(rows_energy_categories) > 0:
142		for row_energy_category in rows_energy_categories:
143		energy_category_set.add(row_energy_category[0])
144
145		# query all energy categories
146		cursor_system.execute(" SELECT id, name, unit_of_measure, kgce, kgco2e "
147		" FROM tbl_energy_categories "
148		" ORDER BY id ", )
149		rows_energy_categories = cursor_system.fetchall()
150	View Code Duplication	if rows_energy_categories is None or len(rows_energy_categories) == 0:
		0 ignored issues – show Duplication introduced 2020-11-24 10:14 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
151		if cursor_system:
152		cursor_system.close()
153		if cnx_system:
154		cnx_system.disconnect()
155
156		if cursor_energy:
157		cursor_energy.close()
158		if cnx_energy:
159		cnx_energy.disconnect()
160
161		if cursor_billing:
162		cursor_billing.close()
163		if cnx_billing:
164		cnx_billing.disconnect()
165
166		raise falcon.HTTPError(falcon.HTTP_404,
167		title='API.NOT_FOUND',
168		description='API.ENERGY_CATEGORY_NOT_FOUND')
169		energy_category_dict = dict()
170		for row_energy_category in rows_energy_categories:
171		if row_energy_category[0] in energy_category_set:
172		energy_category_dict[row_energy_category[0]] = {"name": row_energy_category[1],
173		"unit_of_measure": row_energy_category[2],
174		"kgce": row_energy_category[3],
175		"kgco2e": row_energy_category[4]}
176
177		################################################################################################################
178		# Step 4: query reporting period energy input
179		################################################################################################################
180		reporting_input = dict()
181		if energy_category_set is not None and len(energy_category_set) > 0:
182		for energy_category_id in energy_category_set:
183		reporting_input[energy_category_id] = dict()
184		reporting_input[energy_category_id]['timestamps'] = list()
185		reporting_input[energy_category_id]['values'] = list()
186		reporting_input[energy_category_id]['subtotal'] = Decimal(0.0)
187
188		cursor_energy.execute(" SELECT start_datetime_utc, actual_value "
189		" FROM tbl_tenant_input_category_hourly "
190		" WHERE tenant_id = %s "
191		" AND energy_category_id = %s "
192		" AND start_datetime_utc >= %s "
193		" AND start_datetime_utc < %s "
194		" ORDER BY start_datetime_utc ",
195		(tenant['id'],
196		energy_category_id,
197		reporting_start_datetime_utc,
198		reporting_end_datetime_utc))
199		rows_tenant_hourly = cursor_energy.fetchall()
200
201		rows_tenant_periodically = utilities.aggregate_hourly_data_by_period(rows_tenant_hourly,
202		reporting_start_datetime_utc,
203		reporting_end_datetime_utc,
204		period_type)
205		for row_tenant_periodically in rows_tenant_periodically:
206		current_datetime_local = row_tenant_periodically[0].replace(tzinfo=timezone.utc) + \
207		timedelta(minutes=timezone_offset)
208		if period_type == 'hourly':
209		current_datetime = current_datetime_local.strftime('%Y-%m-%dT%H:%M:%S')
210		elif period_type == 'daily':
211		current_datetime = current_datetime_local.strftime('%Y-%m-%d')
212		elif period_type == 'monthly':
213		current_datetime = current_datetime_local.strftime('%Y-%m')
214		elif period_type == 'yearly':
215		current_datetime = current_datetime_local.strftime('%Y')
216
217		actual_value = Decimal(0.0) if row_tenant_periodically[1] is None else row_tenant_periodically[1]
218		reporting_input[energy_category_id]['timestamps'].append(current_datetime)
		0 ignored issues – show introduced 2020-12-07 10:27 UTC by Report Bug Copy Issue Report The variable `current_datetime` does not seem to be defined for all execution paths. Loading history...
219		reporting_input[energy_category_id]['values'].append(actual_value)
220		reporting_input[energy_category_id]['subtotal'] += actual_value
221
222		################################################################################################################
223		# Step 5: query reporting period energy cost
224		################################################################################################################
225		reporting_cost = dict()
226		if energy_category_set is not None and len(energy_category_set) > 0:
227		for energy_category_id in energy_category_set:
228		reporting_cost[energy_category_id] = dict()
229		reporting_cost[energy_category_id]['timestamps'] = list()
230		reporting_cost[energy_category_id]['values'] = list()
231		reporting_cost[energy_category_id]['subtotal'] = Decimal(0.0)
232
233		cursor_billing.execute(" SELECT start_datetime_utc, actual_value "
234		" FROM tbl_tenant_input_category_hourly "
235		" WHERE tenant_id = %s "
236		" AND energy_category_id = %s "
237		" AND start_datetime_utc >= %s "
238		" AND start_datetime_utc < %s "
239		" ORDER BY start_datetime_utc ",
240		(tenant['id'],
241		energy_category_id,
242		reporting_start_datetime_utc,
243		reporting_end_datetime_utc))
244		rows_tenant_hourly = cursor_billing.fetchall()
245
246		rows_tenant_periodically = utilities.aggregate_hourly_data_by_period(rows_tenant_hourly,
247		reporting_start_datetime_utc,
248		reporting_end_datetime_utc,
249		period_type)
250		for row_tenant_periodically in rows_tenant_periodically:
251		current_datetime_local = row_tenant_periodically[0].replace(tzinfo=timezone.utc) + \
252		timedelta(minutes=timezone_offset)
253		if period_type == 'hourly':
254		current_datetime = current_datetime_local.strftime('%Y-%m-%dT%H:%M:%S')
255		elif period_type == 'daily':
256		current_datetime = current_datetime_local.strftime('%Y-%m-%d')
257		elif period_type == 'monthly':
258		current_datetime = current_datetime_local.strftime('%Y-%m')
259		elif period_type == 'yearly':
260		current_datetime = current_datetime_local.strftime('%Y')
261
262		actual_value = Decimal(0.0) if row_tenant_periodically[1] is None else row_tenant_periodically[1]
263		reporting_cost[energy_category_id]['timestamps'].append(current_datetime)
264		reporting_cost[energy_category_id]['values'].append(actual_value)
265		reporting_cost[energy_category_id]['subtotal'] += actual_value
266
267		################################################################################################################
268		# Step 6: query tariff data
269		################################################################################################################
270		parameters_data = dict()
271		parameters_data['names'] = list()
272		parameters_data['timestamps'] = list()
273		parameters_data['values'] = list()
274		if energy_category_set is not None and len(energy_category_set) > 0:
275		for energy_category_id in energy_category_set:
276		energy_category_tariff_dict = utilities.get_energy_category_tariffs(tenant['cost_center_id'],
277		energy_category_id,
278		reporting_start_datetime_utc,
279		reporting_end_datetime_utc)
280		tariff_timestamp_list = list()
281		tariff_value_list = list()
282		for k, v in energy_category_tariff_dict.items():
283		# convert k from utc to local
284		k = k + timedelta(minutes=timezone_offset)
285		tariff_timestamp_list.append(k.isoformat()[0:19][0:19])
286		tariff_value_list.append(v)
287
288		parameters_data['names'].append('TARIFF-' + energy_category_dict[energy_category_id]['name'])
289		parameters_data['timestamps'].append(tariff_timestamp_list)
290		parameters_data['values'].append(tariff_value_list)
291
292		################################################################################################################
293		# Step 7: construct the report
294		################################################################################################################
295		if cursor_system:
296		cursor_system.close()
297		if cnx_system:
298		cnx_system.disconnect()
299
300		if cursor_energy:
301		cursor_energy.close()
302		if cnx_energy:
303		cnx_energy.disconnect()
304
305		if cursor_billing:
306		cursor_billing.close()
307		if cnx_billing:
308		cnx_billing.disconnect()
309
310		result = dict()
311
312		result['tenant'] = dict()
313		result['tenant']['name'] = tenant['name']
314		result['tenant']['buildings'] = tenant['buildings']
315		result['tenant']['floors'] = tenant['floors']
316		result['tenant']['rooms'] = tenant['rooms']
317		result['tenant']['lease_number'] = tenant['lease_number']
318		result['tenant']['email'] = tenant['email']
319		result['tenant']['phone'] = tenant['phone']
320
321		result['reporting_period'] = dict()
322		result['reporting_period']['names'] = list()
323		result['reporting_period']['energy_category_ids'] = list()
324		result['reporting_period']['units'] = list()
325		result['reporting_period']['subtotals_input'] = list()
326		result['reporting_period']['subtotals_cost'] = list()
327		result['reporting_period']['total_cost'] = Decimal(0.0)
328		result['reporting_period']['currency_unit'] = config.currency_unit
329
330		if energy_category_set is not None and len(energy_category_set) > 0:
331		for energy_category_id in energy_category_set:
332		result['reporting_period']['names'].append(energy_category_dict[energy_category_id]['name'])
333		result['reporting_period']['energy_category_ids'].append(energy_category_id)
334		result['reporting_period']['units'].append(energy_category_dict[energy_category_id]['unit_of_measure'])
335		result['reporting_period']['subtotals_input'].append(reporting_input[energy_category_id]['subtotal'])
336		result['reporting_period']['subtotals_cost'].append(reporting_cost[energy_category_id]['subtotal'])
337		result['reporting_period']['total_cost'] += reporting_cost[energy_category_id]['subtotal']
338
339		result['parameters'] = {
340		"names": parameters_data['names'],
341		"timestamps": parameters_data['timestamps'],
342		"values": parameters_data['values']
343		}
344
345		resp.body = json.dumps(result)
346

myems / myems-api

Push — master ( dc4cf6...d9c3b0 )

reports.tenantbill.Reporting.__init__() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

reports.tenantbill.Reporting.init() A