def unmapped_weldermachineMapping(request):
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['read']:
entity_id = payload['entity_id']
get_unmapped_welder = django_parameterized_query_search_admin_role(
dql_sql=getUnMappedWelder_query, dql_data=(entity_id, ))
get_unmapped_machine = django_parameterized_query_search_admin_role(
dql_sql=getUnMappedMachine_query, dql_data=(entity_id, ))
message = {
"welder": get_unmapped_welder,
"machine": get_unmapped_machine
}
else:
return response_unauthorised()
return response_success(data=message)
except Exception as err:
return response_exception(err)
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
return response_invalid_token()
def machine_delete(request, machineid):
print(machineid)
print(request.method)
payload = jwt_checker(request=request)
if request.method == 'DELETE':
if payload != 0:
try:
if payload['permission']['delete']:
entity_id = payload['entity_id']
delete_tuple = (machineid, entity_id)
data, err = django_parameterized_query_delete(
delete_sql=machine_delete_query,
delete_tuple=delete_tuple)
if data == 0:
return response_conflict(kind='Deleted', err=str(err))
return response_success(
data={"message": "Deleted Successfully"})
else:
return response_unauthorised()
except Exception as err:
return response_exception(err)
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
return response_invalid_token()
else:
return response_request_wrong()
def get_fault_by_date(request, machineid):
if request.method == 'GET':
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['read']:
entity_id = payload['entity_id']
today_date = time_converter()
prvs_date = today_date - 86400000
data = django_parameterized_query_search_admin_role(
dql_sql=getmaxfaultbydays_query,
dql_data=(machineid, entity_id, prvs_date, today_date))
else:
return response_unauthorised()
return response_success(data=data)
except Exception as err:
return response_exception(err)
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
return response_invalid_token()
else:
return response_request_wrong()
def get_all_tickets(request):
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['read']:
startdate = int(request.GET.get('startdate'))
enddate = int(request.GET.get('enddate'))
user_id = payload['userid']
userid = repr(user_id)
entity_id = payload['entity_id']
data = django_query_search_all_any_role(
sql=getAllTicketsCalculated_query.format(
userid=userid,
startdate=startdate,
enddate=enddate,
entity_id=entity_id))
else:
return response_unauthorised()
return response_success(data=data)
except Exception as err:
return response_exception(err)
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
return response_invalid_token()
def add_newnode(request):
"""
this function used for adding device into db
:param request: request from url
:return: device inserted successfully
"""
# Token from the authorization headers
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['create']:
entity_id = payload['entity_id']
request_body = json.loads(request.body)
# Parameters for parameterized query
insert_tuple = (str(request_body[REQ_NODEADDR]), str(request_body[REQ_GATEWAYMAC_ID]),
request_body[REQ_NODE_COMMISSION], entity_id)
# Parameterized insert query
data, err = django_parameterized_query_insert(insert_sql=addNewNode_query,
insert_tuple=insert_tuple)
# If data is zero, error has occurred
if data == 0:
return response_conflict(kind='Insert', err=str(err))
# On success query, success response
return response_success(data={"message": "Inserted Successfully"})
else:
return response_unauthorised()
# If any kind of exception, response will be forbidden
except Exception as err:
return response_exception(err)
# If JWT decode error or expiration, response will be unauthorized
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
# If wrong request, response will be unauthorized
return response_invalid_token()
def add_newmachineinput(request):
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['create']:
# entity_id = payload['entity_id']
request_body = json.loads(request.body)
entity_id = payload['entity_id']
# Parameters for parameterized query
insert_tuple = (request_body[REQ_MACHINE_INPUT_ID],
request_body[REQ_MACHINE_CYCLE_TIME],
request_body[REQ_MACHINE_PRODUCED],
request_body[REQ_MACHINE_REJECTED],
request_body[REQ_MACHINE_TS], entity_id)
# Parameterized insert query
data, err = django_parameterized_query_insert(
insert_sql=insert_MachineInput_query,
insert_tuple=insert_tuple)
# If data is zero, error has occurred
if data == 0:
return response_conflict(kind='Insert', err=str(err))
# On success query, success response
return response_success(
data={"message": "Inserted Successfully"})
else:
return response_unauthorised()
# If any kind of exception, response will be forbidden
except Exception as err:
return response_exception(err)
# If JWT decode error or expiration, response will be unauthorized
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
# If wrong request, response will be unauthorized
return response_invalid_token()
def welder_delete(request, welderid):
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['delete']:
entity_id = payload['entity_id']
delete_tuple = (welderid, entity_id)
data, err = django_parameterized_query_multiple_delete(
delete_sql=welder_delete_query, delete_tuple=delete_tuple)
print(data)
data, err = django_parameterized_query_multiple_delete(
delete_sql=welderMappingDelete_query,
delete_tuple=delete_tuple)
if data == 0:
return response_conflict(kind='Deleted', err=str(err))
return response_success(
data={"message": "Deleted Successfully"})
else:
return response_unauthorised()
except Exception as err:
return response_exception(err)
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
return response_invalid_token()
def user_add(request):
"""
this function used for adding device into db
:param request: request from url
:return: device inserted successfully
"""
# Token from the authorization headers
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['create']:
# role_code = payload['userid']
# Request body from request
# entity_id = payload['entity_id']
request_body = json.loads(request.body)
# Parameters for parameterized query
insert_tuple = (str(request_body[REQ_USERID]),
request_body[REQ_USER_AGE],
str(request_body[REQ_USER_CITY]),
request_body[REQ_USER_CONTACT_NUMBER],
str(request_body[REQ_USER_COUNTRY]),
str(request_body[REQ_USER_FIRST_NAME]),
request_body[REQ_USER_GENDER],
str(request_body[REQ_USER_LAST_NAME]),
str(request_body[REQ_USER_MAILID]),
str(request_body[REQ_USER_PASSWORD]),
str(request_body[REQ_USER_PINCODE]),
request_body[REQ_USER_ROLE],
str(request_body[REQ_USER_STATE]),
request_body[REQ_USER_STATUS],
str(request_body[REQ_USER_USERNAME]),
request_body[REQ_USER_ENTITY_ID])
# Parameterized insert query
data, err = django_parameterized_query_insert(
insert_sql=user_insert_query, insert_tuple=insert_tuple)
# If data is zero, error has occurred
if data == 0:
return response_conflict(kind='Insert', err=str(err))
# On success query, success response
return response_success(
data={"message": "Inserted Successfully"})
else:
return response_unauthorised()
# If any kind of exception, response will be forbidden
except Exception as err:
return response_exception(err)
# If JWT decode error or expiration, response will be unauthorized
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
# If wrong request, response will be unauthorized
return response_invalid_token()
def get_report_details(request):
payload = jwt_checker(request=request)
if payload != 0:
try:
startdate = int(request.GET.get('startdate'))
enddate = int(request.GET.get('enddate'))
converted_d1 = datetime.datetime.fromtimestamp(round(startdate / 1000))
converted_d2 = datetime.datetime.fromtimestamp(round(enddate / 1000))
d = converted_d2 - converted_d1
days = d.days
if payload['permission']['read']:
dailyrecordssumm = django_parameterized_query_search_admin_role(dql_sql=getDailyRecordssumALL_query,
dql_data=(int(startdate), int(enddate)))
data1 = dailyrecordssumm[0]['json_build_object']
if data1['sum'] == None:
data1 = []
dailyrecords_produceall = django_parameterized_query_search_admin_role(dql_sql=getDailyRecordsProducedALL_query,
dql_data=(int(startdate), int(enddate)))
data3 = dailyrecords_produceall[0]['json_build_object']
if data3['jobs'] == None:
data3['jobs'] = []
getDailyRecordsALL = django_parameterized_query_search_admin_role(dql_sql=getDailyRecordsALL_query,
dql_data=(int(startdate), int(enddate)))
data2 = getDailyRecordsALL[0]['json_build_object']
if data2['daywise'] == None:
data2['daywise'] = []
merge = {**data3, **data2, **data1 }
return response_success(data=merge)
elif payload['permission']['read'] and days > 1:
machineid = int(request.GET.get('machineid'))
startdate = int(request.GET.get('startdate'))
enddate = int(request.GET.get('enddate'))
dailyPowerRecordPerMachine = django_parameterized_query_search_admin_role(dql_sql=dailypowerrecordpermachine_query,
dql_data=(machineid, startdate, enddate))
if len(dailyPowerRecordPerMachine) > 0:
sending_response = {
"daywise": dailyPowerRecordPerMachine
}
else:
sending_response = {
"daywise": []
}
return response_success(data=sending_response)
else:
return response_exception(err='Unauthorized')
except Exception as err:
return response_exception(err)
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
return response_invalid_token()
def update_machineconfig_by_id(request, machineid):
if request.method == PUT:
"""
this function used for adding device into db
:param request: request from url
:return: device inserted successfully
"""
# Token from the authorization headers
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['update']:
# Request body from request
request_body = json.loads(request.body)
entity_id = payload['entity_id']
# Parameters for parameterized query
update_tuple = (request_body[REQ_JOB_MIN_GASFLOW],
request_body[REQ_JOB_MAX_GASFLOW],
request_body[REQ_JOB_MIN_WIREFEED],
request_body[REQ_JOB_MAX_WIREFEED],
request_body[REQ_JOB_MIN_VOLTAGE],
request_body[REQ_JOB_MAX_VOLTAGE],
request_body[REQ_JOB_MINTHRESHOLD],
request_body[REQ_JOB_MAXTHRESHOLD],
request_body[REQ_JOBCREATED],
request_body[REQ_JOB_MIN_CURRENT_TIME],
request_body[REQ_JOB_MAX_CURRENT_TIME],
request_body[REQ_JOBID],
request_body[REQ_JOB_CURRENT_MAX_RANGE],
machineid, entity_id)
data, err = django_parameterized_query_update(
update_sql=updateMachineConfig_query,
update_tuple=update_tuple)
# If data is zero, error has occurred
if data == 0:
return response_conflict(kind='update', err=str(err))
# On success query, success response
return response_success(
data={"message": "Updated Successfully"})
else:
return response_unauthorised()
# If any kind of exception, response will be forbidden
except Exception as err:
return response_exception(err)
# If JWT decode error or expiration, response will be unauthorized
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
# If wrong request, response will be unauthorized
return response_invalid_token()
else:
return response_request_wrong()
def power_report(request):
payload = jwt_checker(request=request)
if payload != 0:
try:
machineid = request.GET.get('machineid')
startdate = int(request.GET.get('startdate'))
enddate = int(request.GET.get('enddate'))
converted_d1 = datetime.datetime.fromtimestamp(round(startdate / 1000))
converted_d2 = datetime.datetime.fromtimestamp(round(enddate / 1000))
d = converted_d2 - converted_d1
days =d.days
if payload['permission']['read'] == True and (days == 0 or days < 1):
hourlypowerrecords = django_query_search_all_any_role(sql=hourlyPowerRecordPerMachine_query.
format(machineid=machineid, startdate=startdate,
enddate=enddate))
if len(hourlypowerrecords) > 0:
sending_response = {
"daywise": hourlypowerrecords
}
else:
sending_response = {
"daywise": []
}
return response_success(sending_response)
elif payload['permission']['read'] == True and days > 1:
machineid = int(request.GET.get('machineid'))
startdate = int(request.GET.get('startdate'))
enddate = int(request.GET.get('enddate'))
dailypowerrecordpermachine = django_query_search_all_any_role(sql=dailypowerrecordpermachine_query.
format(machineid=machineid,
startdate=startdate,
enddate=enddate))
if len(dailypowerrecordpermachine) > 0:
sending_response = {
"daywise": dailypowerrecordpermachine
}
else:
sending_response = {
"daywise": []
}
return response_success(data=sending_response)
else:
return response_exception(err='Unauthorized')
except Exception as err:
return response_exception(err)
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
return response_invalid_token()
def get_daily_report(request, machineid):
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['read']:
# machineid = request.GET.get('machineid')
startdate = int(request.GET.get('startdate'))
enddate = int(request.GET.get('enddate'))
jobs = django_parameterized_query_search_admin_role(
dql_sql=getDailyRecordssum_query,
dql_data=(startdate, enddate, machineid))
if len(jobs) == 0:
data1 = {"sum": jobs}
else:
data1 = jobs[0]['json_build_object']
record_produced = django_parameterized_query_search_admin_role(
dql_sql=getDailyRecordsProduced_query,
dql_data=(startdate, enddate, machineid))
data3 = record_produced[0]['json_build_object']
if data3['jobs'] == None:
data3['jobs'] = []
getDailyRecordsPerMachines = django_parameterized_query_search_admin_role(
dql_sql=getDailyRecordsPerMachines_query,
dql_data=(startdate, enddate, machineid))
data2 = getDailyRecordsPerMachines[0]['json_build_object']
if (data2['daywise'] == None):
data2['daywise'] = []
merge = {**data3, **data2, **data1}
return response_success(data=merge)
else:
machineid = int(request.GET.get('machineid'))
startdate = int(request.GET.get('startdate'))
enddate = int(request.GET.get('enddate'))
dailyPowerRecordPerMachine = django_parameterized_query_search_admin_role(
dql_sql=dailypowerrecordpermachine_query,
dql_data=(machineid, startdate, enddate))
if len(dailyPowerRecordPerMachine) > 0:
sending_response = {**dailyPowerRecordPerMachine}
else:
sending_response = {"daywise": []}
return response_success(data=sending_response)
except Exception as err:
return response_exception(err)
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
return response_invalid_token()
def get_all_welders(request):
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['read']:
user_details = django_parameterized_query_search_admin_role(
dql_sql=welder_read_query, dql_data=())
else:
return response_unauthorised()
return response_success(data=user_details)
except Exception as err:
return response_exception(err)
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
return response_invalid_token()
def update_ticket_by_id(request, ticketid):
"""
this function used for adding device into db
:param request: request from url
:return: device inserted successfully
"""
# Token from the authorization headers
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['update']:
# Request body from request
request_body = json.loads(request.body)
entity_id = payload['entity_id']
userid = payload['userid']
# Parameters for parameterized query
update_tuple = (str(request_body[REQ_TICKET_CAUSE]),
str(request_body[REQ_TICKET_REMARK]),
request_body[REQ_TICKET_SEVERITY],
str(request_body[REQ_TICKET_STATUS]), userid,
request_body[REQ_TICKET_REPORTED_DATE],
request_body[REQ_TICKET_CLOSED_DATE],
request_body[REQ_TICKET_MACHINEID], ticketid,
entity_id)
# Parameterized update query
data, err = django_parameterized_query_update(
update_sql=updateTicket_query, update_tuple=update_tuple)
# If data is zero, error has occurred
if data == 0:
return response_conflict(kind='update', err=str(err))
# On success query, success response
return response_success(
data={"message": "Updated Successfully"})
else:
return response_unauthorised()
# If any kind of exception, response will be forbidden
except Exception as err:
return response_exception(err)
# If JWT decode error or expiration, response will be unauthorized
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
# If wrong request, response will be unauthorized
return response_invalid_token()
def get_all_fault(request):
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['read']:
entity_id = payload['entity_id']
data = django_parameterized_query_search_admin_role(
dql_sql=getmaxerrorpermachine_query,
dql_data=(entity_id, ))
else:
return response_unauthorised()
return response_success(data=data)
except Exception as err:
return response_exception(err)
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
return response_invalid_token()
def welder_machine_mapping_read(request):
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['read']:
entity_id = payload['entity_id']
user_details = django_parameterized_query_search_admin_role(
dql_sql=getWelderMachineMapping_query,
dql_data=(entity_id, ))
else:
return response_unauthorised()
return response_success(data=user_details)
except Exception as err:
return response_exception(err)
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
return response_invalid_token()
def update_reportconfig(request):
"""
this function used for adding device into db
:param request: request from url
:return: device inserted successfully
"""
# Token from the authorization headers
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['update']:
# Request body from request
request_body = json.loads(request.body)
entity_id = payload['entity_id']
# Parameters for parameterized query
update_tuple = (request_body[REQ_REPORTCONFIG_WELDER_DAILY_AVAILABLE],
request_body[REQ_REPORTCONFIG_WELDER_POWER_CONSUME],
request_body[REQ_REPORTCONFIG_POWER_RATE_UNIT],
request_body[REQ_REPORTCONFIG_IDLE_POWER_CONSUME],
request_body[REQ_REPORTCONFIG_DAILY_LABOUR_RATE],
request_body[REQ_REPORTCONFIG_DAILY_SHIFT_HOUR],
entity_id)
# Parameterized update query
data, err = django_parameterized_query_update(update_sql=updatereportConfig_query,
update_tuple=update_tuple)
# If data is zero, error has occurred
if data == 0:
return response_conflict(kind='update', err=str(err))
# On success query, success response
return response_success(data={"message": "Updated Successfully"})
else:
return response_unauthorised()
# If any kind of exception, response will be forbidden
except Exception as err:
return response_exception(err)
# If JWT decode error or expiration, response will be unauthorized
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
# If wrong request, response will be unauthorized
return response_invalid_token()
def get_hourly(request):
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['read']:
entity_id = payload['entity_id']
current_date = time_converter()
data = django_parameterized_query_search_admin_role(
dql_sql=getHourly_query,
dql_data=(entity_id, current_date, current_date))
else:
return response_unauthorised()
return response_success(data=data)
except Exception as err:
return response_exception(err)
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
return response_invalid_token()
def welder_mapping_update(request):
"""
this function used for adding device into db
:param request: request from url
:return: device inserted successfully
"""
# Token from the authorization headers
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['update']:
# Request body from request
request_body = json.loads(request.body)
entity_id = payload['entity_id']
# Parameters for parameterized query
update_tuple = (
request_body[REQ_WELDER_MACHINE_MAPPING_WELDERID],
request_body[REQ_WELDER_MACHINE_MAPPING_MACHINEID],
entity_id)
# Parameterized update query
data, err = django_parameterized_query_update(
update_sql=modifyWelderMachineMapping_query,
update_tuple=update_tuple)
# If data is zero, error has occurred
if data == 0:
return response_conflict(kind='update', err=str(err))
# On success query, success response
return response_success(
data={"message": "Updated Successfully"})
else:
return response_unauthorised()
# If any kind of exception, response will be forbidden
except Exception as err:
return response_exception(err)
# If JWT decode error or expiration, response will be unauthorized
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
# If wrong request, response will be unauthorized
return response_invalid_token()
def get_warranty(request, machineid):
if request.method == 'GET':
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['read']:
entity_id = payload['entity_id']
data = django_parameterized_query_search_admin_role(dql_sql=getwarranty_query,
dql_data=(machineid, entity_id))
else:
return response_unauthorised()
return response_success(data=data)
except Exception as err:
return response_exception(err)
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
return response_invalid_token()
else:
return response_request_wrong()
def welder_add(request):
"""
this function used for adding device into db
:param request: request from url
:return: device inserted successfully
"""
# Token from the authorization headers
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['create']:
print("user_create")
request_body = json.loads(request.body)
entity_id = payload['entity_id']
# Parameters for parameterized query
insert_tuple = (str(request_body[REQ_WELDER_FIRSTNAME]),
str(request_body[REQ_WELDER_LASTNAME]), request_body[REQ_WELDER_AGE],
str(request_body[REQ_WELDER_PHONE]), str(request_body[REQ_WELDER_PROFICIENCY]),
request_body[REQ_WELDER_GENDER], entity_id)
# Parameterized insert query
data, err = django_parameterized_query_insert(insert_sql=welder_insert_query,
insert_tuple=insert_tuple)
print(err)
# If data is zero, error has occurred
if data == 0:
return response_conflict(kind='Insert', err=str(err))
# On success query, success response
return response_success(data={"message": "Inserted Successfully"})
else:
return response_unauthorised()
# If any kind of exception, response will be forbidden
except Exception as err:
return response_exception(err)
# If JWT decode error or expiration, response will be unauthorized
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
# If wrong request, response will be unauthorized
return response_invalid_token()
def get_home_overview(request):
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['read']:
current_date = time_converter()
overview = django_parameterized_query_search_admin_role(
dql_sql=getOverview_query, dql_data=(current_date, ))
machine_status = django_parameterized_query_search_admin_role(
dql_sql=getMachinesStatus_query, dql_data=())
data = {"overview": overview, "status": machine_status}
else:
return response_unauthorised()
return response_success(data=data)
except Exception as err:
return response_exception(err)
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
return response_invalid_token()
def get_live_report(request):
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['read']:
machineid = request.GET.get('machineid')
startdate = request.GET.get('startdate')
enddate = request.GET.get('enddate')
data = django_query_search_all_any_role(sql=dailyRecordsPerMachines_query.format(machineid=machineid,
startdate=startdate,
enddate=enddate))
return response_success(data=data)
else:
return response_unauthorised()
except Exception as err:
return response_exception(err)
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
return response_invalid_token()
def read_user(request, userid):
payload = jwt_checker(request=request)
if request.method == 'GET':
if payload != 0:
try:
if payload['permission']['read']:
entity_id = payload['entity_id']
user_id = userid
user_details = django_parameterized_query_search_admin_role(
dql_sql=get_Selected_User,
dql_data=(entity_id, user_id))
else:
return response_unauthorised()
return response_success(data=user_details)
except Exception as err:
return response_exception(err)
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
return response_invalid_token()
else:
return response_request_wrong()
def machine_update(request, machineid):
"""
this function used for adding device into db
:param request: request from url
:return: device inserted successfully
"""
# Token from the authorization headers
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['update']:
userid = payload['userid']
# Request body from request
request_body = json.loads(request.body)
entity_id = payload['entity_id']
# Parameters for parameterized query
update_tuple = (str(request_body[REQ_MACHINE_BUYER_COMPANY]),
str(request_body[REQ_MACHINE_CITY]),
str(request_body[REQ_MACHINE_COUNTRY]),
request_body[REQ_MACHINE_DATE_OF_MANUFACTURE],
request_body[REQ_MACHINE_LATITUDE],
request_body[REQ_MACHINE_LONGITUDE],
str(request_body[REQ_MACHINE_MODEL]),
request_body[REQ_MACHINE_PINCODE],
time_converter(),
request_body[REQ_MACHINE_SENSOR_NODEID],
str(request_body[REQ_MACHINE_STATE]), userid,
machineid, entity_id)
# Parameterized update query
data, err = django_parameterized_query_update(
update_sql=machine_update_query, update_tuple=update_tuple)
print(data)
update_tuple = (request_body[REQ_JOB_MIN_GASFLOW],
request_body[REQ_JOB_MAX_GASFLOW],
request_body[REQ_JOB_MIN_WIREFEED],
request_body[REQ_JOB_MAX_WIREFEED],
request_body[REQ_JOB_MIN_VOLTAGE],
request_body[REQ_JOB_MAX_VOLTAGE],
request_body[REQ_JOB_MINTHRESHOLD],
request_body[REQ_JOB_MAXTHRESHOLD],
request_body[REQ_JOBCREATED],
request_body[REQ_JOB_MIN_CURRENT_TIME],
request_body[REQ_JOB_MAX_CURRENT_TIME],
request_body[REQ_JOBID],
request_body[REQ_JOB_CURRENT_MAX_RANGE],
machineid, entity_id)
data, err = django_parameterized_query_update(
update_sql=updateMachineConfig_query,
update_tuple=update_tuple)
# If data is zero, error has occurred
if data == 0:
return response_conflict(kind='update', err=str(err))
# On success query, success response
return response_success(
data={"message": "Updated Successfully"})
else:
return response_unauthorised()
# If any kind of exception, response will be forbidden
except Exception as err:
return response_exception(err)
# If JWT decode error or expiration, response will be unauthorized
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
# If wrong request, response will be unauthorized
return response_invalid_token()
def machine_add(request):
"""
this function used for adding device into db
:param request: request from url
:return: device inserted successfully
"""
# Token from the authorization headers
payload = jwt_checker(request=request)
if payload != 0:
try:
if payload['permission']['create']:
entity_id = payload['entity_id']
request_body = json.loads(request.body)
# Parameters for parameterized query
insert_tuple = (request_body[REQ_MACHINEID],
str(request_body[REQ_MACHINE_BUYER_COMPANY]),
str(request_body[REQ_MACHINE_CITY]),
str(request_body[REQ_MACHINE_COUNTRY]),
request_body[REQ_MACHINE_LATITUDE],
str(request_body[REQ_MACHINE_LONGITUDE]),
str(request_body[REQ_MACHINE_MODEL]),
request_body[REQ_MACHINE_PINCODE],
str(request_body[REQ_MACHINE_SENSOR_NODEID]),
str(request_body[REQ_MACHINE_STATE]),
str(request_body[REQ_MACHINE_USERID]),
str(request_body[REQ_MACHINE_TAG_NAME]),
time_converter(),
request_body[REQ_MACHINE_SALEDATE], entity_id)
data, err = django_parameterized_query_insert(
insert_sql=machine_insert_query, insert_tuple=insert_tuple)
# Parameterized insert query
try:
# sale_date = request_body[REQ_MACHINE_SALEDATE]
# print(float(sale_date))
sale_date = request_body[REQ_MACHINE_SALEDATE]
# 10 days
warranty_date = sale_date - 864000000
warranty_insert_tuple = (
request_body[REQ_WARRANTY_MACHINEID], sale_date,
warranty_date, entity_id)
data, err = django_parameterized_query_insert(
insert_sql=insert_warrantydetails_query,
insert_tuple=warranty_insert_tuple)
print(data)
insert_tuple1 = (request_body[REQ_JOB_MACHINEID],
request_body[REQ_JOBID],
request_body[REQ_JOB_OPVOLT],
request_body[REQ_JOB_MINTHRESHOLD],
request_body[REQ_JOB_MAXTHRESHOLD],
request_body[REQ_JOB_MIN_CURRENT_TIME],
request_body[REQ_JOB_MAX_CURRENT_TIME],
request_body[REQ_JOB_MIN_GASFLOW],
request_body[REQ_JOB_MAX_GASFLOW],
request_body[REQ_JOB_MIN_WIREFEED],
request_body[REQ_JOB_MAX_WIREFEED],
request_body[REQ_JOB_MIN_VOLTAGE],
request_body[REQ_JOB_MAX_VOLTAGE],
request_body[REQ_JOB_CURRENT_MAX_RANGE],
time_converter(), entity_id,
request_body[REQ_JOB_LOAD],
request_body[REQ_JOB_NOLOAD],
request_body[REQ_WIRESIZE])
data, err = django_parameterized_query_insert(
insert_sql=insert_MachineConfig_query,
insert_tuple=insert_tuple1)
# If data is zero, error has occurred
if data == 0:
return response_conflict(kind='Insert', err=str(err))
except Exception as err:
return response_exception(err)
# On success query, success response
return response_success(
data={"message": "Inserted Successfully"})
else:
return response_unauthorised()
# If any kind of exception, response will be forbidden
except Exception as err:
return response_exception(err)
# If JWT decode error or expiration, response will be unauthorized
except (jwt.DecodeError, jwt.ExpiredSignatureError):
return response_invalid_token()
else:
# If wrong request, response will be unauthorized
return response_invalid_token()
