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()