def update_case(self):
"""
This will data on the bases of the eqipment and console name.This will give the overview for the
dyanmic benchmaraking features
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR}
self._psql_session.execute(MAKE_FALSE_POSTGRES_QUERY.format(self.console, self.equipment))
self._psql_session.execute(MAKE_TRUE_POSTGRES_QUERY.format(self.console, self.equipment, self.case))
return JsonResponse({MESSAGE_KEY: UPDATED_SUCCESSFULLY},
safe=False)
except AssertionError as e:
log_error("Exception due to : %s" + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse({MESSAGE_KEY: EXCEPTION_CAUSE.format(
traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_furnaces(self):
"""
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
self.sync_time = None
data = []
temp = []
try:
self._psql_session.execute(NON_FURNACES_NAME)
df = pd.DataFrame(self._psql_session.fetchall())
temp = yaml.safe_load(df.to_json(orient=RECORDS))
except Exception as e:
log_error('Exception due to get_furnaces Function: %s' +
str(e))
return JsonResponse(temp, safe=False)
except AssertionError as e:
log_error('Exception due to get_furnaces Function: %s' + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def add_user(self):
"""
This function will add the user details
:return: Json payload
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
if self.__is_user_not_authorised():
return JsonResponse({MESSAGE_KEY: NOT_AUTHORISED},
status=HTTP_401_UNAUTHORIZED)
return self.__add_user_query()
except AssertionError as e:
log_error("Exception due to : %s" + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def update_price_input(self):
"""
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
try:
for i in self._request_payload:
self._psql_session.execute(
UPDATE_PRICE_INPUT.format(i['price'],
i["density LB/Gal"],
i["density LB/Bbl"],
i["price_unit"],
i["tag_name"]))
except Exception as e:
log_error('Exception occurs due to: %s' + str(e))
return JsonResponse({MESSAGE_KEY: UPDATED_SUCCESSFULLY})
except AssertionError as e:
log_error('Exception in update_price_input api Function: %s' +
str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_cases_values(self):
"""
This will return the cases for the selected console and equipment
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
self._psql_session.execute(
CASES_POSTGRES_QUERY.format(self.console, self.equipment))
df = pd.DataFrame(self._psql_session.fetchall())
if df.shape[0]:
return JsonResponse(yaml.safe_load(df.to_json(orient=RECORDS)),
safe=False)
return JsonResponse([], safe=False)
except AssertionError as e:
log_error("Exception due to : %s" + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_values(self):
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
temp = []
if self.query_params:
try:
self._psql_session.execute(
FEEDS_CONFIG_FURNACE_NAME.format(
self.query_params[TYPE_REQUEST]))
df = pd.DataFrame(self._psql_session.fetchall())
temp = yaml.safe_load(df.to_json(orient=RECORDS))
except Exception as e:
log_error('Exception due to get_values Function: %s' +
str(e))
return JsonResponse(temp, safe=False)
except AssertionError as e:
log_error('Exception due to get_values Function: %s' + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_algorithms_details(self):
"""
This will return all the list of the algorithm in json format and algorithm status from the Database .
:return: Json Responses
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
final_response = {
"algorithm_status": self.get_algorithm_status(),
"algorithm_name": self.get_algorithm_list()
}
return JsonResponse(final_response, safe=False)
except AssertionError as e:
log_error("Exception due to : %s", e)
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_algorithms_by_name_and_type(self, algorithm_name):
"""
This will return all the list of the algorithm in json format from the Database .
:return: Json Responses
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR}
final_response = {PARAMS: self.get_param_data_by_algorithm_name(algorithm_name),
FILES: self.get_file_data_by_algorithm_name(algorithm_name)}
return JsonResponse(final_response, safe=False)
except AssertionError as e:
log_error("Exception due to : %s", e)
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse({MESSAGE_KEY: EXCEPTION_CAUSE.format(
traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_furnaces(self):
"""
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
dict_data = self.get_dict_data_values()
self.get_ext_and_perf_tags(dict_data)
return JsonResponse(dict_data, safe=False)
except AssertionError as e:
log_error('Exception due to : %s' + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_price_input__data(self, parameter=None):
"""
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
result = []
try:
self._psql_session.execute(get_price_input_data)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
result_data = df['json_build_object'][0]
result.append(result_data)
except Exception as e:
log_error('Exception occurs due to: %s' + str(e))
return JsonResponse(result, safe=False)
except AssertionError as e:
log_error('Exception in get_price_input api Function: %s' + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def delete_user(self):
"""
This function will delete the user details
:return: Json payload
"""
try:
return self.__delete_user_query()
except AssertionError as e:
log_error("Exception due to : %s" + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def update_algorithms(self):
"""
This will return all the list of the algorithm in json format from the Database .
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
LAST_MODIFIED_DATE = str(round(time.time() * 1000))
for algo_data in self.request_payload:
try:
query = UPDATE_PARAM_DATA.format(
NAME, TABLE_NAME, algo_data["param_value"],
algo_data["unit"], algo_data["description"],
algo_data["algo_tag"], LAST_MODIFIED_DATE, FLAG,
self.algo_name, algo_data["file_param_name"])
self._csql_session.execute(query)
log_info("updated--------" +
'---------Algorithm name-------' +
str(self.algo_name) + '----Param name-----' +
str(algo_data["file_param_name"]) +
'------update param value-----' +
str(algo_data["param_value"]))
except Exception as e:
log_error("Exception due to : %s" + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
return JsonResponse({MESSAGE_KEY: UPDATED_SUCCESSFULLY},
safe=False)
except AssertionError as e:
log_error("Exception due to : %s", e)
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def update_algorithms(self):
"""
This will return all the list of the algorithm in json format from the Database .
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
LAST_MODIFIED_DATE = datetime.now()
for algo_data in self.request_payload:
try:
if algo_data["status"]:
query = UPDATE_CONFIGURATION_ACTIVE_STATUS_DATA.format(
algo_data["status"], LAST_MODIFIED_DATE,
algo_data["module"])
else:
query = UPDATE_CONFIGURATION_DEACTIVE_STATUS_DATA.format(
algo_data["status"], LAST_MODIFIED_DATE,
algo_data["module"])
self._psql_session.execute(query)
except Exception as e:
log_error("Exception due to : %s" + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
return JsonResponse({MESSAGE_KEY: UPDATED_SUCCESSFULLY},
safe=False)
except AssertionError as e:
log_error("Exception due to : %s", e)
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def change_password_user(self):
"""
This function will change the user details
:return: Json payload
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
return self.__change_user_password_query()
except AssertionError as e:
log_error("Exception due to : %s" + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def update_external_targets(self):
"""
:return: Json payload
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
return self.__update_external_query()
except AssertionError as e:
log_error("Exception due to update_external_targets Function: %s",
e)
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_furnace_data(self):
"""
This will return the module level data for the furnace module
:return: Json response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
module_level_data = []
error_details = []
furnace_details = []
latest_timestamp = None
dict_data = {
TIMESTAMP_KEY: latest_timestamp,
"data": module_level_data,
"errors": error_details,
"furnaces": furnace_details,
"alarms": []
}
if self.equipment == FURNACE_VALUE:
# if self.module == PASS_A_VALUE:
# tag_name = FURNACE_A_CHECK_STATUS_TAGS
# online_tag = PASS_A_ONLINE_STATUS_TAG
# spall_tag = PASS_A_SPALL_STATUS_TAG
# else:
# tag_name = FURNACE_B_CHECK_STATUS_TAGS
# online_tag = PASS_B_ONLINE_STATUS_TAG
# spall_tag = PASS_B_SPALL_STATUS_TAG
try:
# self._psql_session.execute(FURNACE_TMT_SPALL_CHECK.format(self.module, tuple(tag_name)))
# df_spall_check = pd.DataFrame(self._psql_session.fetchall())
# df_spall_check.set_index(TAG_NAME_REQUEST, inplace=True)
# df_spall_transposed = df_spall_check.T
# if df_spall_transposed[online_tag].iloc[0] == ZERO and df_spall_transposed[spall_tag].iloc[
# 0] == ONE:
# """
# This will return the module level data for the furnace module' spall effectiveness status
# """
# dict_data["is_spall"] = True
# self._psql_session.execute(MODULE_LEVEL_SPALL_DATA.format(self.equipment, self.module))
# df = pd.DataFrame(self._psql_session.fetchall())
# self._psql_session.execute(MODULE_LEVEL_SPALL_TAGS_DATA.format(self.equipment, self.module))
# df_tag = pd.DataFrame(self._psql_session.fetchall())
# else:
"""
This will return the module level data for the furnace module
"""
# dict_data["is_spall"] = False
self._psql_session.execute(
MODULE_LEVEL_TMT_DATA.format(self.equipment,
self.module))
df = pd.DataFrame(self._psql_session.fetchall())
self._psql_session.execute(
MODULE_LEVEL_TMT_TAGS_DATA.format(
self.equipment, self.module))
df_tag = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
df = df.where(pd.notnull(df) == True, None)
dict_data[TIMESTAMP_KEY] = df[CREATE_TS].iloc[0]
df_data = df.drop(columns=CREATE_TS)
dict_data["data"] = dict_data["data"] + yaml.safe_load(
df_data.to_json(orient=RECORDS))
alarm_tags = df_data[
df_data[TAG_NAME_REQUEST].str.contains(ALARM)]
# if dict_data["is_spall"] == False:
reco_tags = df_data[
df_data[TAG_NAME_REQUEST].str.contains('Reco')]
# reco_tags.loc[reco_tags['tag_value'].isnull(), 'condition'] = ' - '
reco_tags = (reco_tags[reco_tags.tag_value.notnull()])
if not reco_tags.empty:
alarm_tags = pd.concat([alarm_tags, reco_tags])
if len(alarm_tags) != 0:
# if dict_data["is_spall"] == True:
# alarm_tags = alarm_tags[alarm_tags.condition != " - "]
if DEBUG == ZERO:
print("Sorry for spall Added new files")
else:
alarm_tags = df_data[
df_data[TAG_NAME_REQUEST].str.contains(ALARM)]
dict_data[
"alarms"] = dict_data["alarms"] + yaml.safe_load(
alarm_tags.to_json(orient=RECORDS))
self._psql_session.execute(
ERROR_DATA.format(self.equipment, self.module,
df[CREATE_TS].iloc[0]))
df_error = pd.DataFrame(self._psql_session.fetchall())
if not df_error.empty:
df_error = df_error.where(
pd.notnull(df_error) == True, None)
df_error = df_error.drop_duplicates()
dict_data["errors"] = dict_data[
"errors"] + yaml.safe_load(
df_error.to_json(orient=RECORDS))
else:
if DEBUG == ONE:
print("Currently no error details!")
if not df_tag.empty:
df_tag = df_tag.where(
pd.notnull(df_tag) == True, None)
df_tag = df_tag.drop(columns=CREATE_TS)
dict_data["furnaces"] = dict_data[
"furnaces"] + yaml.safe_load(
df_tag.to_json(orient=RECORDS))
else:
if DEBUG == ONE:
print(
"Currently no tag details for spall efficiency!"
)
else:
return dict_data
return dict_data
except Exception as e:
log_error("Exception due to : %s" + str(e))
else:
return JsonResponse(
"This equipment is not registered with us!", safe=False)
except AssertionError as e:
log_error("Assertion error due to : %s" + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error("Exception due to : %s" + str(e))
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_furnace_spall_data(self):
"""
This will return the module level data for the furnace module
:return: Json response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
module_level_data = []
error_details = []
furnace_details = []
latest_timestamp = None
rst = None
dict_data = {
TIMESTAMP_KEY: latest_timestamp,
"data": module_level_data,
"errors": error_details,
"furnaces": furnace_details,
"alarms": []
}
if self.module == 'H3901A: Pass 3 & 4 (Spall)':
rst = PASS_A_VALUE
if self.module == 'H3901B: Pass 1 & 2 (Spall)':
rst = PASS_B_VALUE
try:
if self.module == 'H3901A: Pass 3 & 4 (Spall)':
tag_name = FURNACE_A_CHECK_STATUS_TAGS
online_tag = PASS_A_ONLINE_STATUS_TAG
spall_tag = PASS_A_SPALL_STATUS_TAG
else:
tag_name = FURNACE_B_CHECK_STATUS_TAGS
online_tag = PASS_B_ONLINE_STATUS_TAG
spall_tag = PASS_B_SPALL_STATUS_TAG
self._psql_session.execute(
FURNACE_TMT_SPALL_CHECK.format(rst, tuple(tag_name)))
df_spall_check = pd.DataFrame(self._psql_session.fetchall())
df_spall_check.set_index(TAG_NAME_REQUEST, inplace=True)
df_spall_transposed = df_spall_check.T
if df_spall_transposed[online_tag].iloc[
0] == ZERO and df_spall_transposed[spall_tag].iloc[
0] == ONE:
"""
This will return the module level data for the furnace module' spall effectiveness status
"""
dict_data["is_spall"] = True
else:
"""
This will return the module level data for the furnace module
"""
dict_data["is_spall"] = False
self._psql_session.execute(
MODULE_LEVEL_SPALL_DATA.format(self.equipment,
self.module))
df = pd.DataFrame(self._psql_session.fetchall())
self._psql_session.execute(
MODULE_LEVEL_SPALL_TAGS_DATA.format(
self.equipment, self.module))
df_tag = pd.DataFrame(self._psql_session.fetchall())
self._psql_session.execute(
"select max(create_ts) as create_ts from tmt_result t left join equipment_master e on "
"t.equipment_id=e.id "
"where equipment_name = '{}' and module_name ='{}' and create_ts = (SELECT max(create_ts) from "
"tmt_result)".format(self.equipment, rst))
df_time = pd.DataFrame(self._psql_session.fetchall())
self._psql_session.execute(
SPALL_TAGS_DATA.format(self.equipment, self.module))
df_spall_tag = pd.DataFrame(self._psql_session.fetchall())
self._psql_session.execute(
MODULE_LEVEL_SPALL_TAGS.format(self.module))
df_module_tag = pd.DataFrame(self._psql_session.fetchall())
if df.empty:
dict_data[TIMESTAMP_KEY] = df_time[CREATE_TS].iloc[0]
if not df_spall_tag.empty:
df_spall_tag['tag_type'], df_spall_tag[
'tag_value'], df_spall_tag[
'condition'] = None, None, None
dict_data["data"] = dict_data["data"] + yaml.safe_load(
df_spall_tag.to_json(orient=RECORDS))
if not df_module_tag.empty:
df_module_tag['tag_value'], df_module_tag[
'tag_type'], df_module_tag[
'condition'] = None, None, None
dict_data["furnaces"] = dict_data[
"furnaces"] + yaml.safe_load(
df_module_tag.to_json(orient=RECORDS))
if not df.empty:
df = df.where(pd.notnull(df) == True, None)
dict_data[TIMESTAMP_KEY] = df[CREATE_TS].iloc[0]
df_data = df.drop(columns=CREATE_TS)
if not df_spall_tag.empty:
df_data = pd.merge(df_data,
df_spall_tag,
on=[
'tag_name', 'equipment_name',
'module_name', 'equipment_id'
],
how='right')
df_data.drop(['unit_x', 'description_x'],
axis=1,
inplace=True)
df_data.rename(
{
'unit_y': 'unit',
'description_y': 'description'
},
axis=1,
inplace=True)
dict_data["data"] = dict_data["data"] + yaml.safe_load(
df_data.to_json(orient=RECORDS))
alarm_tags = df_data[
df_data[TAG_NAME_REQUEST].str.contains(ALARM)]
if len(alarm_tags) != 0:
alarm_tags = alarm_tags[alarm_tags.condition != " - "]
alarm_tags = alarm_tags[
alarm_tags['condition'].notna()]
else:
alarm_tags = df_data[
df_data[TAG_NAME_REQUEST].str.contains(ALARM)]
dict_data["alarms"] = dict_data["alarms"] + yaml.safe_load(
alarm_tags.to_json(orient=RECORDS))
self._psql_session.execute(
ERROR_DATA.format(self.equipment, self.module,
df[CREATE_TS].iloc[0]))
df_error = pd.DataFrame(self._psql_session.fetchall())
if not df_error.empty:
df_error = df_error.where(
pd.notnull(df_error) == True, None)
df_error = df_error.drop_duplicates()
dict_data[
"errors"] = dict_data["errors"] + yaml.safe_load(
df_error.to_json(orient=RECORDS))
else:
if DEBUG == ONE:
print("Currently no error details!")
if not df_tag.empty:
df_tag = df_tag.where(pd.notnull(df_tag) == True, None)
df_tag = df_tag.drop(columns=CREATE_TS)
if not df_module_tag.empty:
df_tag = pd.merge(df_tag,
df_module_tag,
on=[
'tag_name', 'equipment_name',
'module_name'
],
how='right')
df_tag.drop(['unit_x', 'description_x'],
axis=1,
inplace=True)
df_tag.rename(
{
'unit_y': 'unit',
'description_y': 'description'
},
axis=1,
inplace=True)
dict_data["furnaces"] = dict_data[
"furnaces"] + yaml.safe_load(
df_tag.to_json(orient=RECORDS))
else:
if DEBUG == ONE:
print(
"Currently no tag details for spall efficiency!"
)
else:
return dict_data
return dict_data
except Exception as e:
log_error("Exception due to : %s" + str(e))
except AssertionError as e:
log_error("Assertion error due to : %s" + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error("Exception due to : %s" + str(e))
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_names_values(self):
"""
This will return the names for every unit with console and equipments
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
if self.get_value == 0:
self._psql_session.execute(MASTER_TABLE_QUERY)
elif self.get_value == 1:
self._psql_session.execute(
MASTER_TABLE_QUERY_OPERATOR.format(HOT_CONSOLE_1_VALUE))
elif self.get_value == 2:
self._psql_session.execute(
MASTER_TABLE_QUERY_OPERATOR.format(HOT_CONSOLE_2_VALUE))
elif self.get_value == 3:
self._psql_session.execute(
MASTER_TABLE_QUERY_OPERATOR.format(COLD_CONSOLE_1_VALUE))
elif self.get_value == 4:
self._psql_session.execute(
MASTER_TABLE_QUERY_OPERATOR.format(COLD_CONSOLE_2_VALUE))
df = pd.DataFrame(self._psql_session.fetchall())
if df.shape[0]:
unit_name = df["unit_name"].unique()
console_name = df["console_name"].unique()
unit_val = {}
final_val = []
for unit in unit_name:
console_val = []
for console in console_name:
equipment_val = {}
equipment_val["console_name"] = console
equipment_val["equipments"] = df[[
"equipment_tag_name", "equipment_name",
"equipment_id"
]][(df["console_name"] == console)
& (df["unit_name"] == unit)].to_dict(orient=RECORDS)
console_val.append(equipment_val)
unit_val["unit_name"] = unit
unit_val["consoles"] = console_val
final_val.append(unit_val)
return JsonResponse(final_val, safe=False)
return JsonResponse([], safe=False)
except AssertionError as e:
log_error("Exception due to : %s", e)
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_values(self):
"""
This will return the hgi multi line graph data
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR}
graph = []
max_data = None
min_data = None
empty_dict = {"data": [],
"description": None,
"unit": None,
"min_data": None,
"max_data": None
}
dict1 = {}
dict2 = {}
dict3 = {}
dict4 = {}
dict5 = {}
dict6 = {}
dict7 = {"data": []}
if self.equipment == COKE_DRUM_VALUE and self.module == HGI_VALUE:
query_params = {
START_DATE_REQUEST: self.query_params.GET[START_DATE_REQUEST],
END_DATE_REQUEST: self.query_params.GET[END_DATE_REQUEST]
}
if TAG_NAME_REQUEST not in self.query_params.GET:
"""
This will return the hgi multi line graph data without the secondary tag
"""
multi_line_tags = tuple(HGI_MULTI_LINE_TAGS)
if query_params[START_DATE_REQUEST] and query_params[END_DATE_REQUEST]:
multiline_data = django_search_query_all(HGI_MULTI_LINE_GRAPH.format(
self.module,
multi_line_tags,
query_params[START_DATE_REQUEST],
query_params[END_DATE_REQUEST]))
df_data = pd.DataFrame(multiline_data)
min_max = django_search_query_all(HGI_MIN_MAX_DATA.format(
self.module,
multi_line_tags))
elif TAG_NAME_REQUEST in self.query_params.GET:
query_params[TAG_NAME_REQUEST] = self.query_params.GET[TAG_NAME_REQUEST]
if query_params[START_DATE_REQUEST] and query_params[END_DATE_REQUEST] and query_params[
TAG_NAME_REQUEST]:
"""
This will return the hgi multi line graph data with the primary tag
"""
if query_params[TAG_NAME_REQUEST] in HGI_SECONDARY_TAGS:
HGI_MULTI_LINE_TAGS.append(query_params["tag_name"])
else:
if DEBUG == 1:
print("Sorry tag is not there")
tags = tuple(HGI_MULTI_LINE_TAGS)
multiline_data = django_search_query_all(HGI_MULTI_LINE_GRAPH.format(
self.module,
tags,
query_params[START_DATE_REQUEST],
query_params[END_DATE_REQUEST]))
df_data = pd.DataFrame(multiline_data)
min_max = django_search_query_all(HGI_MIN_MAX_DATA.format(
self.module,
tags))
HGI_MULTI_LINE_TAGS.pop()
if TAG_NAME_REQUEST in self.query_params.GET:
if not df_data.empty:
query_params[TAG_NAME_REQUEST] = self.query_params.GET[TAG_NAME_REQUEST]
final_dict = {
HGI_PRED: dict1,
NORTH_HGI_PRED: dict2,
NORTH_HGI_ACTUAL: dict3,
SOUTH_HGI_PRED: dict4,
SOUTH_HGI_ACTUAL: dict5,
query_params[TAG_NAME_REQUEST]: dict6,
"x-axis": dict7,
}
else:
final_dict = {
HGI_PRED: empty_dict,
NORTH_HGI_PRED: empty_dict,
NORTH_HGI_ACTUAL: empty_dict,
SOUTH_HGI_PRED: empty_dict,
SOUTH_HGI_ACTUAL: empty_dict,
query_params[TAG_NAME_REQUEST]: empty_dict,
"x-axis": dict7,
}
else:
if not df_data.empty:
final_dict = {
HGI_PRED: dict1,
NORTH_HGI_PRED: dict2,
NORTH_HGI_ACTUAL: dict3,
SOUTH_HGI_PRED: dict4,
SOUTH_HGI_ACTUAL: dict5,
"tags_list": HGI_SECONDARY_TAGS,
"x-axis": dict7,
}
else:
final_dict = {
HGI_PRED: empty_dict,
NORTH_HGI_PRED: empty_dict,
NORTH_HGI_ACTUAL: empty_dict,
SOUTH_HGI_PRED: empty_dict,
SOUTH_HGI_ACTUAL: empty_dict,
"tags_list": HGI_SECONDARY_TAGS,
"x-axis": dict7
}
df_min_max_data = pd.DataFrame(min_max)
if not df_data.empty:
df_data = df_data.where(pd.notnull(df_data) == True, None)
df_data.sort_values(TIMESTAMP_KEY, ascending=True, inplace=True)
data_now = df_data.groupby(TAG_NAME_REQUEST)
df_time = df_data[TIMESTAMP_KEY].unique()
old_dict = {}
for name, group in data_now:
old_dict[name] = list(group[TAG_VALUE])
keys = []
for key in old_dict.keys():
keys.append(key)
if HGI_PRED in keys:
unit = df_data[df_data[TAG_NAME_REQUEST].str.contains(HGI_PRED)][UNIT].iloc[0]
description = df_data[df_data[TAG_NAME_REQUEST].str.contains(HGI_PRED)][DESCRIPTION].iloc[0]
if not df_min_max_data.empty:
min_data = \
df_min_max_data[df_min_max_data[TAG_NAME_REQUEST].str.contains(HGI_PRED)][
MIN_VALUE].iloc[
0]
max_data = \
df_min_max_data[df_min_max_data[TAG_NAME_REQUEST].str.contains(HGI_PRED)][
MAX_VALUE].iloc[
0]
dict1["data"] = old_dict[HGI_PRED]
dict1["unit"] = unit
dict1["description"] = description
dict1["min_data"] = min_data
dict1["max_data"] = max_data
elif HGI_PRED not in keys:
dict1["data"] = []
dict1["unit"] = None
dict1["description"] = None
dict1["min_data"] = None
dict1["max_data"] = None
if NORTH_HGI_PRED in keys:
unit = df_data[df_data[TAG_NAME_REQUEST].str.contains(NORTH_HGI_PRED)][UNIT].iloc[0]
description = df_data[df_data[TAG_NAME_REQUEST].str.contains(NORTH_HGI_PRED)][DESCRIPTION].iloc[
0]
if not df_min_max_data.empty:
min_data = \
df_min_max_data[df_min_max_data[TAG_NAME_REQUEST].str.contains(NORTH_HGI_PRED)][
MIN_VALUE].iloc[0]
max_data = \
df_min_max_data[df_min_max_data[TAG_NAME_REQUEST].str.contains(NORTH_HGI_PRED)][
MAX_VALUE].iloc[0]
dict2["data"] = old_dict[NORTH_HGI_PRED]
dict2["unit"] = unit
dict2["description"] = description
dict2["min_data"] = min_data
dict2["max_data"] = max_data
elif NORTH_HGI_PRED not in keys:
dict2["data"] = []
dict2["unit"] = None
dict2["description"] = None
dict2["min_data"] = None
dict2["max_data"] = None
if NORTH_HGI_ACTUAL in keys:
unit = df_data[df_data[TAG_NAME_REQUEST].str.contains(NORTH_HGI_ACTUAL)][UNIT].iloc[0]
description = \
df_data[df_data[TAG_NAME_REQUEST].str.contains(NORTH_HGI_ACTUAL)][DESCRIPTION].iloc[
0]
if not df_min_max_data.empty:
min_data = \
df_min_max_data[df_min_max_data[TAG_NAME_REQUEST].str.contains(NORTH_HGI_ACTUAL)][
MIN_VALUE].iloc[
0]
max_data = \
df_min_max_data[df_min_max_data[TAG_NAME_REQUEST].str.contains(NORTH_HGI_ACTUAL)][
MAX_VALUE].iloc[
0]
dict3["data"] = old_dict[NORTH_HGI_ACTUAL]
dict3["unit"] = unit
dict3["description"] = description
dict3["min_data"] = min_data
dict3["max_data"] = max_data
elif NORTH_HGI_ACTUAL not in keys:
dict3["data"] = []
dict3["unit"] = None
dict3["description"] = None
dict3["min_data"] = None
dict3["max_data"] = None
if SOUTH_HGI_PRED in keys:
unit = df_data[df_data[TAG_NAME_REQUEST].str.contains(SOUTH_HGI_PRED)][UNIT].iloc[0]
description = df_data[df_data[TAG_NAME_REQUEST].str.contains(SOUTH_HGI_PRED)][DESCRIPTION].iloc[
0]
if not df_min_max_data.empty:
min_data = \
df_min_max_data[df_min_max_data[TAG_NAME_REQUEST].str.contains(SOUTH_HGI_PRED)][
MIN_VALUE].iloc[
0]
max_data = \
df_min_max_data[df_min_max_data[TAG_NAME_REQUEST].str.contains(SOUTH_HGI_PRED)][
MAX_VALUE].iloc[
0]
dict4["data"] = old_dict[SOUTH_HGI_PRED]
dict4["unit"] = unit
dict4["description"] = description
dict4["min_data"] = min_data
dict4["max_data"] = max_data
elif SOUTH_HGI_PRED not in keys:
dict4["data"] = []
dict4["unit"] = None
dict4["description"] = None
dict4["min_data"] = None
dict4["max_data"] = None
if SOUTH_HGI_ACTUAL in keys:
unit = df_data[df_data[TAG_NAME_REQUEST].str.contains(SOUTH_HGI_ACTUAL)][UNIT].iloc[0]
description = \
df_data[df_data[TAG_NAME_REQUEST].str.contains(SOUTH_HGI_ACTUAL)][DESCRIPTION].iloc[
0]
if not df_min_max_data.empty:
min_data = \
df_min_max_data[df_min_max_data[TAG_NAME_REQUEST].str.contains(SOUTH_HGI_ACTUAL)][
MIN_VALUE].iloc[
0]
max_data = \
df_min_max_data[df_min_max_data[TAG_NAME_REQUEST].str.contains(SOUTH_HGI_ACTUAL)][
MAX_VALUE].iloc[
0]
dict5["data"] = old_dict[SOUTH_HGI_ACTUAL]
dict5["unit"] = unit
dict5["description"] = description
dict5["min_data"] = min_data
dict5["max_data"] = max_data
elif SOUTH_HGI_ACTUAL not in keys:
dict5["data"] = []
dict5["unit"] = None
dict5["description"] = None
dict5["min_data"] = None
dict5["max_data"] = None
if TAG_NAME_REQUEST in self.query_params.GET:
if query_params[TAG_NAME_REQUEST] in keys:
unit = \
df_data[df_data[TAG_NAME_REQUEST].str.contains(query_params[TAG_NAME_REQUEST])][
UNIT].iloc[0]
description = \
df_data[df_data[TAG_NAME_REQUEST].str.contains(query_params[TAG_NAME_REQUEST])][
DESCRIPTION].iloc[0]
if not df_min_max_data.empty:
min_tags = list(df_min_max_data[TAG_NAME_REQUEST])
if query_params[TAG_NAME_REQUEST] in min_tags:
min_data = \
df_min_max_data[
df_min_max_data[TAG_NAME_REQUEST].str.contains(
query_params[TAG_NAME_REQUEST])][
MIN_VALUE].iloc[0]
max_data = \
df_min_max_data[
df_min_max_data[TAG_NAME_REQUEST].str.contains(
query_params[TAG_NAME_REQUEST])][
MAX_VALUE].iloc[0]
else:
min_data = None
max_data = None
dict6["data"] = old_dict[query_params[TAG_NAME_REQUEST]]
dict6["unit"] = unit
dict6["description"] = description
dict6["min_data"] = min_data
dict6["max_data"] = max_data
else:
dict6["data"] = []
dict6["unit"] = None
dict6["description"] = None
dict6["min_data"] = None
dict6["max_data"] = None
else:
if DEBUG == 1:
print("sorry")
dict7["data"] = list(df_time)
graph.append(final_dict)
return JsonResponse(graph, safe=False)
except AssertionError as e:
log_error("Assertion error due to : %s" + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error("Exception due to : %s" + str(e))
return JsonResponse({MESSAGE_KEY: EXCEPTION_CAUSE.format(
traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_values(self):
"""
This will return the revenue loss data for the overhead pdi module value
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
if self.equipment == COKE_DRUM_VALUE:
if self.query_params:
if START_DATE_REQUEST not in self.query_params or not self.query_params[
START_DATE_REQUEST]:
self._psql_session.execute(
DETAILED_REVENUE_GRAPH_NULL_START_DATE.format(
self.module,
self.query_params[TAG_NAME_REQUEST],
self.query_params[END_DATE_REQUEST]))
else:
self._psql_session.execute(
DETAILED_REVENUE_GRAPH.format(
self.module,
self.query_params[TAG_NAME_REQUEST],
self.query_params[START_DATE_REQUEST],
self.query_params[END_DATE_REQUEST]))
df_data = pd.DataFrame(self._psql_session.fetchall())
graph = []
temp = {}
if not df_data.empty:
df_data = df_data.where(
pd.notnull(df_data) == True, None)
df_data.sort_values(TIMESTAMP_KEY,
ascending=True,
inplace=True)
df_temp = df_data[df_data[MODULE_NAME] == PDI_VALUE]
if not df_temp.empty:
temp["unit"] = df_temp[UNIT].iloc[0]
temp["y_axis"] = list(df_temp[TAG_VALUE])
temp["x_axis"] = list(df_temp[TIMESTAMP_KEY])
else:
temp["unit"] = None
temp["y_axis"] = []
temp["x_axis"] = []
if START_DATE_REQUEST not in self.query_params or not self.query_params[
START_DATE_REQUEST]:
self._psql_session.execute(
DETAILED_COST_GRAPH_NULL_START_DATE.format(
self.module,
self.query_params[END_DATE_REQUEST]))
else:
self._psql_session.execute(
DETAILED_COST_GRAPH.format(
self.module,
self.query_params[START_DATE_REQUEST],
self.query_params[END_DATE_REQUEST]))
df_cost_data = pd.DataFrame(self._psql_session.fetchall())
if not df_cost_data.empty:
df_cost_data = df_cost_data.where(
pd.notnull(df_cost_data) == True, None)
df_cost_data.sort_values(MODIFIED_TIME,
ascending=True,
inplace=True)
# df_cost_temp = df_cost_data[df_cost_data[MODULE_NAME] == PDI_VALUE]
temp["updated_price"] = df_cost_data.to_dict(
orient=RECORDS)
else:
temp["updated_price"] = []
graph.append(temp)
return JsonResponse(graph, safe=False)
except AssertionError as e:
log_error("Assertion error due to : %s" + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error("Exception due to : %s" + str(e))
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def update_equip(self, body, equipment, feed_name, is_active):
"""
This function will update external targets
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
conn = pg_connection()
if conn:
cursor = conn.cursor()
try_now = list(body.keys())
count = 0
counter = 0
performance_case_name = body[
try_now[count]]['performance_tags']
if is_active == 'true' and int(equipment[0]) < 15:
try:
try:
for each_equipment in equipment:
try:
for each in json.loads(
json.dumps(body[try_now[counter]]
['external_targets'])):
if float(each["min"]) <= float(
each['target']):
update_external_lbt = SET_UPDATE_EXTERNAL_TAGS_LBT.format(
('Between' + ' ' +
each["min"] + ' and ' +
each["max"]), each['target'],
each['is_active'], is_active,
each_equipment, feed_name,
each['parameter'])
cursor.execute(update_external_lbt)
else:
pass
counter += 1
except Exception as e:
pass
try:
conn.commit()
except Exception as commit_err:
log_error(commit_err)
except Exception as e:
log_error("The Exception is" + str(e))
if int(equipment[0]) < 15:
for each_equipment in equipment:
update_perf_lbt = update_perf(
body[try_now[count]]['performance_tags'],
each_equipment, is_active)
cursor.execute(update_perf_lbt)
count += 1
else:
pass
except Exception as err:
pass
elif int(equipment[0]) > 14:
try:
for each in json.loads(
json.dumps(
body[try_now[count]]['external_targets'])):
if float(each["min"]) <= float(each['target']):
update_external_lbt = UPDATED_QUERY_FOR_EXTERANL_TARGETS_NON_FURNACE.format(
('Between' + ' ' + each["min"] + ' and ' +
each["max"]), each['target'],
each['is_active'], equipment[0],
each['parameter'])
cursor.execute(update_external_lbt)
else:
return JsonResponse({MESSAGE_KEY: SET_LIMIT},
status=404)
if int(equipment[0]) > 14:
update_perf_lbt = update_perf(
body[try_now[0]]['performance_tags'],
equipment[0], is_active)
cursor.execute(update_perf_lbt)
else:
pass
case_equip = UPDATE_CASE_EQUIPMENT_MAPPING.format(
equipment[0])
cursor.execute(case_equip)
insert_case = INSERT_CASE_EQUIP_MAPPING.format(
equipment[0], performance_case_name)
cursor.execute(insert_case)
except Exception as err:
log_error("The Exception is" + str(err))
else:
print('The Function Done')
try:
conn.commit()
except Exception as commit_err:
log_error(commit_err)
if conn:
cursor.close()
conn.close()
return 0
except AssertionError as e:
log_error('Exception due to update_equip Function: %s' + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def download_file(self):
"""
This will download all the zip files (contains xml/csv) for the selected algorithm.
:return: zip file to download
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
files = self.query_params["files"].split(",")
if len(files) == 1:
query = SINGLE_FILE_DOWNLOAD_QUERY.format(
NAME, TABLE_NAME, self.algorithm_name, files[0])
else:
query = MULTIPLE_FILES_DOWNLOAD_QUERY.format(
NAME, TABLE_NAME, self.algorithm_name, tuple(files))
result_set = self._csql_session.execute(query)
result_set_list = list(result_set)
if len(result_set_list) != len(files):
return JsonResponse("Please enter the correct file names",
safe=False)
df_data = pd.DataFrame(result_set_list)
"""
Creates Zip File
"""
file_to_download = self.algorithm_name + ".zip"
zip_object = zipfile.ZipFile(file_to_download, "w")
"""
Iterate each file(row entry from DB) and creates csv, xml files inside zip file with the file name
"""
for index, row in df_data.iterrows():
extension = os.path.splitext(row['file_param_name'])[1]
if extension == ".csv":
df = pd.read_json(row['value'])
zip_object.writestr(row['file_param_name'],
df.to_csv(index=False))
elif extension == ".xml":
obj = json.loads(row['value'])
xml = dicttoxml.dicttoxml(obj, root=False, attr_type=False)
xml.partition(b'<?xml version="1.0" encoding="UTF-8" ?>'
) # added the xml version
dom = parseString(xml)
zip_object.writestr(row['file_param_name'],
dom.toprettyxml())
elif extension == ".joblib":
#obj = json.loads(unescape(row['value']))
value = unescape(row['value'])
# print(value)
# print(joblib.dump(value, "hgi.joblib"))
# file_name = os.path.splitext(row['file_param_name'])[0]
# print(joblib.dump(bytes(value, 'utf-8'), row['file_param_name']))
# zip_object.writestr(row['file_param_name'], joblib.dump(value, row['file_param_name']))
# n = os.path.splitext(row['file_param_name'])[0]
# a = n+'.sav'
print(joblib.dump(value, row['file_param_name']))
# zip_object.writestr(row['file_param_name'], joblib.dump(value, a))
zip_object.writestr(row['file_param_name'], value)
# for row in modelDetails.index:
# functionName = str(modelDetails.loc[row, 'functionName'])
# modelName = str(modelDetails.loc[row, 'modelName']) + ".joblib"
# modelPath = os.path.join(self.folder, "lib", modelName)
# model = joblib.load(modelPath)
# self.savedModels[functionName] = model
# , joblib.dump(value, row['file_param_name'])
zip_object.close()
"""Download Created Zip File"""
with open(file_to_download, 'rb') as fh:
response = HttpResponse(fh.read(),
content_type="application/zip")
response[
'Content-Disposition'] = 'attachment; file_name=' + os.path.basename(
file_to_download)
return response
except AssertionError as e:
log_error("Exception due to : %s", e)
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def upload_file(self):
"""
This will upload all the selected csv/xml files in the Database for the given algorithm.
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
batch = BatchStatement()
error = False
error_message = None
if not self.files:
error = True
error_message = "No files to upload"
file_names_list = self.file_names
select_query = SELECT_ALGORITHM_NAME_QUERY.format(
NAME, TABLE_NAME, self.algo_name,
",".join(map(lambda x: "'" + x + "'", file_names_list)))
result_set = self._csql_session.execute(select_query)
if result_set[0]['count'] == 0 or result_set[0]['count'] < len(
file_names_list):
error_message = "Please give the existing algorithm or file name"
return JsonResponse({MESSAGE_KEY: error_message},
status=HTTP_500_INTERNAL_SERVER_ERROR)
for file in self.files:
if file.name not in self.file_names:
error = True
error_message = "Uploaded file name(" + file.name + ") not found in given file name list"
break
description = None
if file.name in self.description:
description = self.description[file.name]
LAST_MODIFIED_DATE = str(round(time.time() * 1000))
extension = os.path.splitext(file.name)[1]
json_data = ""
if self.algo_name == 'last_10_tmt' and file.name == 'features.csv':
file_data = pandas.read_csv(file,
encoding='unicode escape')
json_data = file_data.to_json()
elif extension == ".csv":
file_data = pandas.read_csv(file, encoding='ISO-8859-1')
json_data = file_data.to_json()
elif extension == ".xml":
file_data = et.parse(file)
xml_str = ElementTree.tostring(file_data.getroot(),
encoding='unicode')
json_data = json.dumps(xmltodict.parse(xml_str))
elif extension == ".joblib":
json_datas = joblib.load(file)
json_data = escape(str(json_datas))
""" insert query into cassandra table """
insert_query = FILE_UPLOAD_QUERY.format(
NAME, TABLE_NAME, self.algo_name, file.name, description,
"textAsBlob('" + json_data + "')", LAST_MODIFIED_DATE,
FLAG)
batch.add(SimpleStatement(insert_query))
if error is True:
return JsonResponse({MESSAGE_KEY: error_message},
status=HTTP_500_INTERNAL_SERVER_ERROR)
self._csql_session.execute(batch, timeout=200.0)
return JsonResponse({MESSAGE_KEY: UPLOADED_SUCCESSFULLY},
safe=False)
except AssertionError as e:
log_error("Exception due to : %s", e)
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_values(self):
"""
This will return the outage multiline graph data
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
graph = []
empty_dict = {
"data": [],
"description": None,
"unit": None,
"min_data": None,
"max_data": None
}
dict1 = {}
dict2 = {}
dict3 = {}
dict4 = {}
dict5 = {"data": []}
if self.equipment == COKE_DRUM_VALUE and self.module == OUTAGE_VALUE:
query_params = {
START_DATE_REQUEST:
self.query_params.GET[START_DATE_REQUEST],
END_DATE_REQUEST: self.query_params.GET[END_DATE_REQUEST]
}
if PRIMARY_TAG not in self.query_params.GET:
"""
This will return the outage multiline graph data without the primary tag
"""
multiline_tags = tuple(LIST_OF_OUTAGE_MULTILINE_TAGS)
if query_params[START_DATE_REQUEST] and query_params[
END_DATE_REQUEST]:
multi_line = django_search_query_all(
OUTAGE_MULTILINE.format(
self.module, multiline_tags,
query_params[START_DATE_REQUEST],
query_params[END_DATE_REQUEST]))
df_data = pd.DataFrame(multi_line)
min_max = django_search_query_all(
OUTAGE_MIN_MAX_DATA.format(self.module,
multiline_tags))
elif PRIMARY_TAG in self.query_params.GET:
query_params[PRIMARY_TAG] = self.query_params.GET[
PRIMARY_TAG]
if query_params[START_DATE_REQUEST] and query_params[
END_DATE_REQUEST] and query_params[PRIMARY_TAG]:
"""
This will return the outage multiline graph data with the primary tag
"""
LIST_OF_OUTAGE_MULTILINE_TAGS.append(
query_params["primary_tag"])
tags = tuple(LIST_OF_OUTAGE_MULTILINE_TAGS)
multi_line = django_search_query_all(
OUTAGE_MULTILINE.format(
self.module, tags,
query_params[START_DATE_REQUEST],
query_params[END_DATE_REQUEST]))
df_data = pd.DataFrame(multi_line)
min_max = django_search_query_all(
OUTAGE_MIN_MAX_DATA.format(self.module, tags))
LIST_OF_OUTAGE_MULTILINE_TAGS.pop()
if PRIMARY_TAG in self.query_params.GET:
if not df_data.empty:
query_params[PRIMARY_TAG] = self.query_params.GET[
PRIMARY_TAG]
final_dict = {
"Coke Height": dict1,
"Foam Height": dict2,
"Current Outage": dict3,
query_params[PRIMARY_TAG]: dict4,
"x-axis": dict5,
"online-drum": []
}
else:
final_dict = {
"Coke Height": empty_dict,
"Foam Height": empty_dict,
"Current Outage": empty_dict,
query_params[PRIMARY_TAG]: empty_dict,
"x-axis": dict5,
"online-drum": []
}
else:
if not df_data.empty:
final_dict = {
"Coke Height": dict1,
"Foam Height": dict2,
"Current Outage": dict3,
"x-axis": dict5,
"tags_list": LIST_OF_OUTAGE_PRIMARY_TAGS,
"online-drum": []
}
else:
final_dict = {
"Coke Height": empty_dict,
"Foam Height": empty_dict,
"Current Outage": empty_dict,
"x-axis": dict5,
"tags_list": LIST_OF_OUTAGE_PRIMARY_TAGS,
"online-drum": []
}
df_min_max_data = pd.DataFrame(min_max)
if not df_data.empty:
df_data = df_data.where(pd.notnull(df_data) == True, None)
df_data.sort_values(TIMESTAMP_KEY,
ascending=True,
inplace=True)
data_now = df_data.groupby(TAG_NAME_REQUEST)
df_time = df_data[TIMESTAMP_KEY].unique()
data_online_coke = data_now.get_group(COKE_HEIGHT_TAG)
data_online_foam = data_now.get_group(FOAM_HEIGHT_TAG)
data_online_current = data_now.get_group(FOAM_HEIGHT_TAG)
if not data_online_coke.empty:
final_dict["online-drum"] = list(
data_online_coke[DRUM_ONLINE])
elif not data_online_foam.empty:
final_dict["online-drum"] = list(
data_online_foam[DRUM_ONLINE])
elif not data_online_current.empty:
final_dict["online-drum"] = list(
data_online_current[DRUM_ONLINE])
old_dict = {}
for name, group in data_now:
old_dict[name] = list(group[TAG_VALUE])
keys = []
for key in old_dict.keys():
keys.append(key)
if COKE_HEIGHT_TAG in keys:
unit = df_data[df_data[TAG_NAME_REQUEST].str.contains(
COKE_HEIGHT)][UNIT].iloc[0]
description = df_data[
df_data[TAG_NAME_REQUEST].str.contains(
COKE_HEIGHT)][DESCRIPTION].iloc[0]
min_data = \
df_min_max_data[df_min_max_data[TAG_NAME_REQUEST].str.contains(COKE_HEIGHT)][
MIN_VALUE].iloc[
0]
max_data = \
df_min_max_data[df_min_max_data[TAG_NAME_REQUEST].str.contains(COKE_HEIGHT)][
MAX_VALUE].iloc[
0]
dict1["data"] = old_dict[COKE_HEIGHT_TAG]
dict1["unit"] = unit
dict1["description"] = description
dict1["min_data"] = min_data
dict1["max_data"] = max_data
elif COKE_HEIGHT_TAG not in keys:
dict1["data"] = None
dict1["unit"] = None
dict1["description"] = None
dict1["min_data"] = None
dict1["max_data"] = None
if FOAM_HEIGHT_TAG in keys:
unit = df_data[df_data[TAG_NAME_REQUEST].str.contains(
FOAM_HEIGHT)][UNIT].iloc[0]
description = df_data[
df_data[TAG_NAME_REQUEST].str.contains(
FOAM_HEIGHT)][DESCRIPTION].iloc[0]
min_data = \
df_min_max_data[df_min_max_data[TAG_NAME_REQUEST].str.contains(FOAM_HEIGHT)][
MIN_VALUE].iloc[0]
max_data = \
df_min_max_data[df_min_max_data[TAG_NAME_REQUEST].str.contains(FOAM_HEIGHT)][
MAX_VALUE].iloc[0]
dict2["data"] = old_dict[FOAM_HEIGHT_TAG]
dict2["unit"] = unit
dict2["description"] = description
dict2["min_data"] = min_data
dict2["max_data"] = max_data
elif FOAM_HEIGHT_TAG not in keys:
dict2["data"] = None
dict2["unit"] = None
dict2["description"] = None
dict2["min_data"] = None
dict2["max_data"] = None
if OUTAGE_TREND_TAG in keys:
unit = df_data[df_data[TAG_NAME_REQUEST].str.contains(
CURRENT_OUTAGE)][UNIT].iloc[0]
description = df_data[
df_data[TAG_NAME_REQUEST].str.contains(
CURRENT_OUTAGE)][DESCRIPTION].iloc[0]
min_data = \
df_min_max_data[df_min_max_data[TAG_NAME_REQUEST].str.contains(CURRENT_OUTAGE)][
MIN_VALUE].iloc[
0]
max_data = \
df_min_max_data[df_min_max_data[TAG_NAME_REQUEST].str.contains(CURRENT_OUTAGE)][
MAX_VALUE].iloc[
0]
dict3["data"] = old_dict[OUTAGE_TREND_TAG]
dict3["unit"] = unit
dict3["description"] = description
dict3["min_data"] = min_data
dict3["max_data"] = max_data
elif OUTAGE_TREND_TAG not in keys:
dict3["data"] = None
dict3["unit"] = None
dict3["description"] = None
dict3["min_data"] = None
dict3["max_data"] = None
if PRIMARY_TAG in self.query_params.GET:
if query_params[PRIMARY_TAG] in keys:
data_online_primary = data_now.get_group(
query_params[PRIMARY_TAG])
if not data_online_primary.empty:
final_dict["online-drum"] = list(
data_online_primary[DRUM_ONLINE])
else:
print("sorry")
unit = \
df_data[df_data[TAG_NAME_REQUEST].str.contains(query_params[PRIMARY_TAG])][UNIT].iloc[0]
description = \
df_data[df_data[TAG_NAME_REQUEST].str.contains(query_params[PRIMARY_TAG])][
DESCRIPTION].iloc[0]
min_data = \
df_min_max_data[
df_min_max_data[TAG_NAME_REQUEST].str.contains(query_params[PRIMARY_TAG])][
MIN_VALUE].iloc[0]
max_data = \
df_min_max_data[
df_min_max_data[TAG_NAME_REQUEST].str.contains(query_params[PRIMARY_TAG])][
MAX_VALUE].iloc[0]
dict4["data"] = old_dict[query_params[PRIMARY_TAG]]
dict4["unit"] = unit
dict4["description"] = description
dict4["min_data"] = min_data
dict4["max_data"] = max_data
else:
dict4["data"] = None
dict4["unit"] = None
dict4["description"] = None
dict4["min_data"] = None
dict4["max_data"] = None
else:
print("sorry")
dict5["data"] = list(df_time)
graph.append(final_dict)
return JsonResponse(graph, safe=False)
except AssertionError as e:
log_error("Assertion error due to : %s" + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error("Exception due to : %s" + str(e))
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_values(self):
"""
This will get query from the Database for the console and equipment name
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
self._psql_session.execute(CONFIGURATON_SINGLE_PERF)
perf = pd.DataFrame(self._psql_session.fetchall())
if not perf.empty:
value = perf['case_name'].to_string()
result = ''.join([i for i in value if not i.isdigit()]).strip()
else:
result = []
dict_data = {
"Targets": [],
"Performance_tag": result,
"Match_tags": [],
"Noise_Tags": [],
"Performance_tags_list": []
}
dynamic_benchmarking_df = pd.DataFrame()
try:
self._psql_session.execute(CONFIGURATION_TARGETS_TAGS)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
df = df.where(pd.notnull(df) == True, None)
dynamic_benchmarking_df = dynamic_benchmarking_df.append(
df, ignore_index=True)
dict_data["Targets"] = yaml.safe_load(
df.to_json(orient=RECORDS))
except Exception as e:
log_error(e)
try:
self._psql_session.execute(CONFIGURATION_MATCH_TAGS)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
df = df.where(pd.notnull(df) == True, None)
dynamic_benchmarking_df = dynamic_benchmarking_df.append(
df, ignore_index=True)
dict_data["Match_tags"] = yaml.safe_load(
df.to_json(orient=RECORDS))
except Exception as e:
log_error(e)
try:
self._psql_session.execute(CONFIGURATION_PERF_TAGS_LIST)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
df = df.where(pd.notnull(df) == True, None)
dynamic_benchmarking_df = dynamic_benchmarking_df.append(
df, ignore_index=True)
dict_data["Performance_tags_list"] = yaml.safe_load(
df.to_json(orient=RECORDS))
except Exception as e:
log_error(e)
try:
self._psql_session.execute(CONFIGURATION_NOISE_TAGS)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
df = df.where(pd.notnull(df) == True, None)
dynamic_benchmarking_df = dynamic_benchmarking_df.append(
df, ignore_index=True)
dict_data["Noise_Tags"] = yaml.safe_load(
df.to_json(orient=RECORDS))
except Exception as e:
log_error(e)
return JsonResponse(dict_data, safe=False)
except AssertionError as e:
log_error(e)
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_externl_targets(self):
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
self._psql_session.execute(
"select timestamp from color_coding_graph limit 1 ")
timetsamp_record = self._psql_session.fetchone()
if not timetsamp_record:
return JsonResponse(
"No data available right now ! We'll be sending the empty response soon! ",
)
self.sync_time = timetsamp_record[TIMESTAMP_KEY]
self._psql_session.execute(GET_EXTERNAL_TARGET_RESULT)
df = pd.DataFrame(self._psql_session.fetchall())
if df.shape[0]:
df = df.where(pd.notnull(df) == True, None)
console_name = df["console_name"].unique()
unit_val = {}
final_val = []
console_val = []
for console in console_name:
equipment_val = {
"console_name":
console,
"equipments":
df[[
"equipment_tag_name", "min", "max", "target",
"actual", "feed_type", "comment", "description",
"status", "alert_flag", "tag", "equipment_id"
]][(df["console_name"] == console)].to_dict(
orient=RECORDS)
}
console_val.append(equipment_val)
unit_val = console_val
final_val.append(unit_val)
return JsonResponse(final_val, safe=False)
else:
return JsonResponse([], safe=False)
except AssertionError as e:
log_error('Exception due to get_externl_targets Function: %s' +
str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_furnaces(self):
"""
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
if self.query_params:
equipment = self.query_params[EQUIPMENT].split(",")
"""
This condition for used to it will select single equipment also even multiple equipment also
based on user selection
"""
if len(equipment) == 1:
equipment_param = '(' + str(equipment[0]) + ')'
equipment_param = '(' + str(equipment[0]) + ')'
else:
equipment_param = tuple(equipment)
perform_list_all = []
try:
if self.query_params[IS_ACTIVE] == "true" and int(
equipment[0]) < 15:
self._psql_session.execute(
MULTIPLE_CONFIG_EQUIPMENT.format(
self.query_params[IS_ACTIVE], equipment_param,
self.query_params[FEED_NAME]))
elif int(equipment[0]) > 14:
self._psql_session.execute(
NON_FURNACE_EXTERNAL_TARGETS.format(
equipment_param))
else:
pass
df = pd.DataFrame(self._psql_session.fetchall())
dt = df.groupby('equipment_tag_name').apply(
lambda x: x.to_json(orient='records'))
df.sort_values('parameter', ascending=True, inplace=True)
obj = {}
array = []
for each_data in dt:
for each in json.loads(each_data):
obj[each['equipment_tag_name']] = {
'external_targets': json.loads(each_data),
'performance_tags': None
}
perform = []
try:
self._psql_session.execute(
MULTIPLE_CONFIG_CASE_NAME_PERFORMACE_TAGS.format(
equipment_param))
except Exception as e:
log_error(
'Exception due to get_furnaces Function: %s' +
str(e))
performance_list = json.loads(
json.dumps(self._psql_session.fetchall()))
perf_list = json.loads(json.dumps(performance_list))
try:
self._psql_session.execute(
ALL_PERF_TAGS_FOR_NON_FURNACES.format(
equipment_param))
except Exception as e:
log_error(
'Exception due to get_furnaces Function: %s' +
str(e))
perameter_list = json.loads(
json.dumps(self._psql_session.fetchall()))
perform_list = json.loads(json.dumps(perameter_list))
if len(perform_list) > 0:
for each_perform in perform_list:
perform_list_all.append(each_perform['result'])
else:
pass
for each_data in perf_list:
try:
obj[each_data["equipment_tag_name"]][
"performance_tags"] = each_data['case_name']
except Exception as err:
pass
for each_data in perform_list_all:
try:
obj[each_data["equipment_tag_name"]][
"performance_tags_list"] = each_data[
'parameter']
except Exception as err:
pass
return JsonResponse(obj, safe=False, status=200)
except Exception as e:
log_error('Exception due to get_furnaces Function: %s' +
str(e))
return JsonResponse({"message": str(e)}, safe=False)
except AssertionError as e:
log_error('Exception due to get_furnaces Function: %s' + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_sanky_output(self):
"""
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
result = []
max_production_overview_data = None
min_spec_energy_overview_data = None
config_msg = None
dict_data = {}
try:
""" Getting the Max_production_current ts,historical best,ambient condition,feed slate"""
dict_data["max_production_overview"] = {}
try:
self._psql_session.execute(max_production_overview)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
max_production_overview_data = df
dict_data["max_production_overview"] = {
"feed_slate":
max_production_overview_data.feed_slate.iloc[0],
"ambient_condition":
max_production_overview_data.ambient_condition.
iloc[0],
"timestamp":
max_production_overview_data.timestamp.iloc[0],
"hystorical_best":
max_production_overview_data.hystorical_best.
iloc[0],
}
else:
dict_data["max_production_overview"] = {}
except Exception as e:
log_error('Exception in max_production_overview_data: %s' +
str(e))
""" ADDING CONFIG_MESSAGE """
try:
self._psql_session.execute(max_production_config_msg_data)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
config_msg = df
dict_data["max_production_overview"][
"config_message"] = config_msg.tag_value_txt.iloc[
0]
else:
dict_data["max_production_overview"][
"config_message"] = None
except Exception as e:
log_error(
'Exception in max_production_overview_data_config_message: %s'
+ str(e))
"""Getting minimum energy current ts,historical best,ambient condition,feed slate data"""
dict_data["min_spec_energy_overview"] = {}
try:
self._psql_session.execute(min_sp_energy_overview)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
min_spec_energy_overview_data = df
dict_data["min_spec_energy_overview"] = {
"feed_slate":
min_spec_energy_overview_data.feed_slate.iloc[0],
"ambient_condition":
min_spec_energy_overview_data.ambient_condition.
iloc[0],
"timestamp":
min_spec_energy_overview_data.timestamp.iloc[0],
"hystorical_best":
min_spec_energy_overview_data.hystorical_best.
iloc[0]
}
else:
dict_data["min_spec_energy_overview"] = {}
except Exception as e:
log_error('Exception in min_spec_energy_overview: : %s' +
str(e))
try:
self._psql_session.execute(min_sp_energy_config_msg_data)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
config_msg = df
dict_data["min_spec_energy_overview"][
"config_message"] = config_msg.tag_value_txt.iloc[
0]
else:
dict_data["min_spec_energy_overview"][
"config_message"] = None
except Exception as e:
log_error(
'Exception in min_spec_energy_overview_data_config_message: %s'
+ str(e))
""" Getting the Max_production total margin data"""
dict_data["max_production_data"] = {}
try:
self._psql_session.execute(max_production_total_margin)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
dict_data["max_production_data"][
"Total Margin"] = yaml.safe_load(
df.to_json(orient="records"))
else:
dict_data["max_production_data"]["Total Margin"] = []
except Exception as e:
log_error(
'Exception in max_production_data total_margin: %s' +
str(e))
"""TOTAL RAW MATERIAL"""
try:
self._psql_session.execute(
max_production_total_raw_material)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
dict_data["max_production_data"][
"Total Raw Material"] = yaml.safe_load(
df.to_json(orient="records"))
else:
dict_data["max_production_data"][
"Total Raw Material"] = []
except Exception as e:
log_error(
'Exception in max_production_data total_raw_material: %s'
+ str(e))
"""PRODUCT"""
try:
self._psql_session.execute(max_production_product_data)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
dict_data["max_production_data"][
"Product"] = yaml.safe_load(
df.to_json(orient="records"))
else:
dict_data["max_production_data"]["Product"] = []
except Exception as e:
log_error(
'Exception in max_production_data product data: %s' +
str(e))
"""Max_product_data energy data"""
try:
self._psql_session.execute(max_production_energy_data)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
dict_data["max_production_data"][
"Energy"] = yaml.safe_load(
df.to_json(orient="records"))
else:
dict_data["max_production_data"]["Energy"] = []
except Exception as e:
log_error(
'Exception in max_production_data energy data: %s' +
str(e))
"""Getting min_spec_energy_data"""
dict_data["min_spec_energy_data"] = {}
try:
self._psql_session.execute(min_sp_energy_total_margin)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
dict_data["min_spec_energy_data"][
"Total Margin"] = yaml.safe_load(
df.to_json(orient="records"))
else:
dict_data["min_spec_energy_data"]["Total Margin"] = []
except Exception as e:
log_error(
'Exception in min_spec_energy_data total_margin: %s' +
str(e))
"""TOTAL RAW MATERIAL"""
try:
self._psql_session.execute(
min_sp_energy_total_raw_material)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
dict_data["min_spec_energy_data"][
"Total Raw Material"] = yaml.safe_load(
df.to_json(orient="records"))
else:
dict_data["min_spec_energy_data"][
"Total Raw Material"] = []
except Exception as e:
log_error(
'Exception in min_spec_energy_data total_raw_material: %s'
+ str(e))
"""min_spec_energy_data PRODUCT"""
try:
self._psql_session.execute(min_sp_energy_product_data)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
dict_data["min_spec_energy_data"][
"Product"] = yaml.safe_load(
df.to_json(orient="records"))
else:
dict_data["min_spec_energy_data"]["Product"] = []
except Exception as e:
log_error(
'Exception in min_spec_energy_data product data: %s' +
str(e))
"""min_spec_energy_data energy data"""
try:
self._psql_session.execute(min_sp_energy_energy_data)
df = pd.DataFrame(self._psql_session.fetchall())
if not df.empty:
dict_data["min_spec_energy_data"][
"Energy"] = yaml.safe_load(
df.to_json(orient="records"))
else:
dict_data["min_spec_energy_data"]["Energy"] = []
except Exception as e:
log_error(
'Exception in min_spec_energy_data energy data: %s' +
str(e))
result.append(dict_data)
except Exception as e:
log_error('Exception due to get_sanky_output Function: %s' +
str(e))
return JsonResponse(dict_data, safe=False)
except AssertionError as e:
log_error('Exception in get_sanky_output Function: %s' + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error(traceback.format_exc())
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_values(self):
"""
This will return the furnace runlength graph data
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
graph = []
tag_left = None
dict_data = {}
if self.equipment == FURNACE_VALUE:
query_params = {
START_DATE_REQUEST:
self.query_params.GET[START_DATE_REQUEST],
END_DATE_REQUEST: self.query_params.GET[END_DATE_REQUEST]
}
multi_line_tags = None
if self.module == FURNACE_A_VALUE:
multi_line_tags = tuple(FURNACE_A_RUN_LENGTH_TAGS)
elif self.module == FURNACE_B_VALUE:
multi_line_tags = tuple(FURNACE_B_RUN_LENGTH_TAGS)
"""
This will return the furnace runlength graph data
"""
if query_params[START_DATE_REQUEST] and query_params[
END_DATE_REQUEST]:
self._psql_session.execute(
FURNACE_MULTI_LINE_GRAPH.format(
self.module, multi_line_tags,
query_params[START_DATE_REQUEST],
query_params[END_DATE_REQUEST],
query_params[START_DATE_REQUEST]))
df_data = pd.DataFrame(self._psql_session.fetchall())
self._psql_session.execute(
FURNACE_MIN_MAX_DATA.format(self.module,
multi_line_tags))
df_min_max_data = pd.DataFrame(
self._psql_session.fetchall())
if not df_data.empty:
df_data = df_data.where(
pd.notnull(df_data) == True, None)
df_time = list(df_data['timestamp'].unique())
df = df_data.groupby("tag_name")
if not df_min_max_data.empty:
for name, group in df:
if name in list(df_min_max_data["tag_name"]):
group['tag_value'] = group[
'tag_value'].astype(float).round()
group = group.where(
pd.notnull(group) == True, None)
dict_data[name] = {
"data":
group[TAG_VALUE].to_list(),
"description":
group['description'].iloc[0],
"unit":
group['unit'].iloc[0],
"min_data":
df_min_max_data[
df_min_max_data["tag_name"] ==
name][MIN_VALUE].iloc[0],
"max_data":
df_min_max_data[
df_min_max_data["tag_name"] ==
name][MAX_VALUE].iloc[0]
}
else:
dict_data[name] = {
"data": group[TAG_VALUE].to_list(),
"description":
group['description'].iloc[0],
"unit": group['unit'].iloc[0],
"min_data": None,
"max_data": None
}
dict_data["x-axis"] = {"data": df_time}
# if TAG_NAME_REQUEST not in self.query_params.GET:
if self.module == FURNACE_A_VALUE:
tag_left = list(FURNACE_A_RUN_LENGTH_TAGS -
dict_data.keys())
else:
tag_left = list(FURNACE_B_RUN_LENGTH_TAGS -
dict_data.keys())
for each in tag_left:
dict_data[each] = {
"data": [],
"description": None,
"unit": None,
"min_data": None,
"max_data": None
}
else:
# if TAG_NAME_REQUEST not in self.query_params.GET:
if self.module == FURNACE_A_VALUE:
tag_left = FURNACE_A_RUN_LENGTH_TAGS
else:
tag_left = FURNACE_B_RUN_LENGTH_TAGS
for each in tag_left:
dict_data[each] = {
"data": [],
"description": None,
"unit": None,
"min_data": None,
"max_data": None
}
dict_data["x-axis"] = {"data": []}
graph.append(dict_data)
return JsonResponse(graph, safe=False)
except AssertionError as e:
log_error("Assertion error due to : %s" + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error("Exception due to : %s" + str(e))
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
def get_names_values(self):
"""
This will return the names for all the equipment and module
:return: Json Response
"""
try:
assert self._db_connection, {
STATUS_KEY: HTTP_500_INTERNAL_SERVER_ERROR,
MESSAGE_KEY: DB_ERROR
}
self._psql_session.execute(MASTER_TABLE_QUERY)
df = pd.DataFrame(self._psql_session.fetchall())
df = pd.DataFrame(df, index=[0, 1, 2, 3, 5, 4, 6])
# df.loc[df['module_name'] == 'H3901A: Pass 3 & 4(Spall)', 'id'] = 5
# df.loc[df['module_name'] == 'H3901A: Pass 3 & 4 (Spall)', 'id'] = 5
# df.loc[df['module_name'] == 'H3901B: Pass 1 & 2', 'id'] = 6
# df.sort_values(by=['id'], inplace=True)
hgi = self.loggedin_userid_details['permissions']['HGI']
over_head_pdi = self.loggedin_userid_details['permissions']['PDI']
outage = self.loggedin_userid_details['permissions']['Outage']
furnace_a = self.loggedin_userid_details['permissions'][
'Furnace: H3901A']
furnace_a_spall = self.loggedin_userid_details['permissions'][
'Furnace: H3901A (Spall)']
furnace_b = self.loggedin_userid_details['permissions'][
'Furnace: H3901B']
furnace_b_spall = self.loggedin_userid_details['permissions'][
'Furnace: H3901B (Spall)']
left_equipment = self.loggedin_userid_details['permissions'][
'Left Pane']
if 'Equipment' not in left_equipment:
return JsonResponse([], safe=False)
if 'Left Pane : Module Access' not in hgi:
df.drop(df.loc[df['module_name'] == 'HGI'].index, inplace=True)
if 'Left Pane : Module Access' not in furnace_a:
df.drop(
df.loc[df['module_name'] == 'H3901A: Pass 3 & 4'].index,
inplace=True)
if 'Left Pane : Module Access' not in furnace_a_spall:
df.drop(df.loc[df['module_name'] ==
'H3901A: Pass 3 & 4 (Spall)'].index,
inplace=True)
if 'Left Pane : Module Access' not in furnace_b_spall:
df.drop(df.loc[df['module_name'] ==
'H3901B: Pass 1 & 2 (Spall)'].index,
inplace=True)
if 'Left Pane : Module Access' not in furnace_b:
df.drop(
df.loc[df['module_name'] == 'H3901B: Pass 1 & 2'].index,
inplace=True)
if 'Left Pane : Module Access' not in outage:
df.drop(df.loc[df['module_name'] == 'Outage'].index,
inplace=True)
if 'Left Pane : Module Access' not in over_head_pdi:
df.drop(df.loc[df['module_name'] == 'Overhead PDI'].index,
inplace=True)
if df.shape[0]:
unit_val = {}
final_val = []
equipment_name = df[EQUIPMENT_NAME].unique()
equipment_val = []
for equipment in equipment_name:
module_val = {
"equipment_name":
equipment,
"modules":
df[[MODULE_NAME,
ID]][(df[EQUIPMENT_NAME] == equipment)].to_dict(
orient=RECORDS)
}
equipment_val.append(module_val)
unit_val["unit_name"] = EQUIPMENT
unit_val["equipments"] = equipment_val
final_val.append(unit_val)
return JsonResponse(final_val, safe=False)
return JsonResponse([], safe=False)
except AssertionError as e:
log_error("Assertion error due to : %s" + str(e))
return JsonResponse({MESSAGE_KEY: e.args[0][MESSAGE_KEY]},
status=e.args[0][STATUS_KEY])
except Exception as e:
log_error("Exception due to : %s" + str(e))
return JsonResponse(
{MESSAGE_KEY: EXCEPTION_CAUSE.format(traceback.format_exc())},
status=HTTP_500_INTERNAL_SERVER_ERROR)
