Esempio n. 1
0
def login_api(request):
    """The Login API checks to see if the user is trying to login with a valid Customer_Number and Password"""

    data = request.data
    json_data = json.loads(data)

    #If test is passed as an input and its true, we set the test flag as true to use the Testing database
    if "test" in json_data:
        test = json_data["test"]
    else:
        test = False

    Customer_Number = json_data["Customer_Number"]
    Password = json_data["Password"]

    #Validating the input to only process valid data. We return an error if the data is not valid
    valid_input = Validate_Input(json_data["Customer_Number"],
                                 json_data["Password"])

    if not valid_input:
        return ('', 400)  #bad request

    db_context = open_connection(test)
    cur = db_context.cursor()

    cur.execute(
        'SELECT * FROM public."Customers" c WHERE c."Active" = true AND c."Customer_Number" = %s',
        (Customer_Number, ))
    result_set = cur.fetchall()

    result = []

    #f the result_set is [], a user with the customer number doesnt exist and we return a 404 error
    if not result_set:
        close_connection(cur, db_context)
        return ('', 404)

    colnames = [desc[0] for desc in cur.description]
    customer = result_set[0]

    result = dict(zip(colnames, customer))
    response = {}

    password_check = check_password(result['PasswordHash'], Password)

    if password_check:
        response['Customer_Id'] = result['Id']

        # Closing the databse connection before returning the result
        close_connection(cur, db_context)

        # Return the JSON object and the Http 200 status to show a success status
        return json.dumps(response), status.HTTP_200_OK

    else:
        # Returning the HTTP code 204 because the server successfully processed the request, but is not returning any content.
        return ('', 204)
Esempio n. 2
0
def delete_device_api(request):
    data = request.data
    json_data = json.loads(data)

    Id = json_data['device_id']

    valid_input = Validate_Input(Id)

    if (not valid_input):
        # return HTTP 400. Bad request
        return ('Invalid data, Please check the documentation', 400)

    if "test" in json_data:
        test = json_data["test"]
    else:
        test = False

    db_context = open_connection(test)
    cur = db_context.cursor()

    cur.execute('SELECT * FROM public."Devices" WHERE "Id" = %s', (Id, ))

    # Fetching the result
    result_set = cur.fetchall()

    if (result_set == []):
        # return HTTP 404. Device not found
        close_connection(cur, db_context)
        return ('', 404)

    # Executing the query
    cur.execute('UPDATE public."Devices" SET "Active" = False WHERE "Id" = %s',
                (Id, ))
    db_context.commit()
    # Closing the databse connection before returning the result
    close_connection(cur, db_context)

    # Return the Http 200 status to show a succcess status
    return ('', 200)
Esempio n. 3
0
def view_api(request):
    """The View API returns a list of all the devices assigned to a customer"""
    customer_Id = request.args.get('customer_Id')
    test = False
    if not customer_Id:
        # Reading the parameters from the body
        data = request.data
        json_data = json.loads(data)

        # Saving the parameters as string
        customer_Id = json_data["customer_Id"]

        # Checking to see if the test value is passed to the API, If test is true, the testing database is used
        if "test" in json_data:
            test = json_data["test"]
        else:
            test = False

    valid_input = Validate_Input(customer_Id)

    if not valid_input:
        # Returning the HTTP code 204 because the server successfully processed the request, but is not returning any content.
        return ('', 204)

    # Opening the connection to the database
    db_context = open_connection(test)
    cur = db_context.cursor()

    # Executing the query
    cur.execute(
        'SELECT * FROM public."Customers" c, public."CustomerLocations" cl, public."Locations" l WHERE c."Id" = cl."CustomerId" AND cl."LocationId" = l."Id" And c."Id" = %s',
        (customer_Id, ))

    # Fetching the result
    result_set = cur.fetchall()
    result = []

    if not result_set:
        # Returning the HTTP code 204 because the server successfully processed the request, but is not returning any content.
        close_connection(cur, db_context)
        return ('', 204)

    colnames = [desc[0] for desc in cur.description]

    result = dict(zip(colnames, result_set[0]))
    response = {}

    response['customer_details'] = {
        'Customer_Number': result['Customer_Number'],
        'Location_Id': result['LocationId'],
        'Location_Name': result['Name']
    }

    cur.execute(
        'SELECT * FROM public."Customers" c, public."CustomerDevices" cp, public."Devices" p WHERE p."Active" = True AND c."Id" = cp."CustomerId" AND cp."DeviceId" = p."Id" AND c."Id" = %s',
        (customer_Id, ))

    # Fetching the result
    result_set_device_list = cur.fetchall()
    result_device_list = []

    # Checking to see if there are any devices associated with the customer
    if result_set_device_list:
        colnames_device_list = [desc[0] for desc in cur.description]

        for row in result_set_device_list:
            result_device_list.append(dict(zip(colnames_device_list, row)))

    response['customer_devices'] = []

    for row in result_device_list:
        response['customer_devices'].append({
            'Device_Id': row['DeviceId'],
            'Device_Name': row['Name']
        })

    # Closing the databse connection before returning the result
    close_connection(cur, db_context)

    # Return the JSON object and the Http 200 status to show a succcess status
    return json.dumps(response), status.HTTP_200_OK
Esempio n. 4
0
def edit_device_api(request):
    data = request.data
    json_data = json.loads(data)
    
    Name = json_data['Name']
    Compressor_status = json_data['Compressor_status']
    Fan_status = json_data['Fan_status']
    Temperature = json_data['Temperature']
    Ip_Address = json_data['Ip_Address']
    Serial_Number = json_data['Serial_Number']
    Mac_Address = json_data['Mac_Address']
    Communication_Frequency = json_data['Communication_Frequency']
    Installation_Date = json_data['Installation_Date']
    Write_Frequency = json_data['Write_Frequency']
    Write_Time = json_data['Write_Time']
    Reporting_Url = json_data['Reporting_Url']

    valid_input = Validate_Input(Name, Compressor_status, Fan_status, Temperature, Ip_Address, Serial_Number, Mac_Address, Communication_Frequency, Installation_Date, Write_Frequency, Write_Time, Reporting_Url)

    if (not valid_input):
        # Returning the HTTP code 400. Bad request
        return ('Invalid data, Please check the documentation', 400)
    
    Temperature_alert = '1' if Temperature > 80 else '0'
    Timestamp = str(time.strftime("%m/%d/%Y %H:%M:%S"))

    # Checking to see if the test value is passed to the API, If test is true, the testing database is used
    if "test" in json_data:
        test = json_data["test"]
    else:
        test = False

    db_context = open_connection(test)
    cur = db_context.cursor()

    # Executing the query
    cur.execute('SELECT * FROM public."Devices" WHERE "Mac_Address" = %s AND "Serial_Number" = %s',(Mac_Address, Serial_Number))

    # Fetching the result
    result_set_check = cur.fetchall()
    exists = True
    # Checking to see if the device exists
    if(result_set_check == []):
        exists = False

    if (exists):
        Compressor_status_string = str(Compressor_status)
        Fan_status_string = str(Fan_status)
        Temperature_string = str(Temperature)
        Communication_Frequency_string = str(Communication_Frequency)
        Write_Frequency_string = str(Write_Frequency)
        Write_Time_string = str(Write_Time)
        Active = 'true'
        colnames = [desc[0] for desc in cur.description]        
        device = result_set_check[0]

        # Saving the result as a key, value pair
        result = dict(zip(colnames,device))
        Id = str(result['Id'])

        cur.execute('UPDATE public."Devices" SET "Name"=%s, "Compressor_status"=%s, "Fan_status"=%s, "Temperature_alert"=%s, "Temperature"=%s, "Ip_Address"=%s, "Communication_Frequency"=%s, "Write_Frequency"=%s, "Write_Time"=%s, "Reporting_Url"=%s, "Timestamp"=%s, "Active"=%s Where "Id"= %s', (Name, Compressor_status_string, Fan_status_string, Temperature_alert, Temperature_string, Ip_Address, Communication_Frequency_string, Write_Frequency_string, Write_Time_string, Reporting_Url, Timestamp, Active, Id))
        db_context.commit()
    
         # Closing the databse connection before returning the result
        close_connection(cur, db_context)
        
        # Return the Http 200 status to show a succcess status
        return ('', 200)
    
    close_connection(cur, db_context)
    # Return the Http 404 status to show that the device does not exist
    return ('Device does not exist', 404)
Esempio n. 5
0
def add_device_api(request):
    data = request.data
    json_data = json.loads(data)
    
    Name = json_data['Name']
    Compressor_status = json_data['Compressor_status']
    Fan_status = json_data['Fan_status']
    Temperature = json_data['Temperature']
    Ip_Address = json_data['Ip_Address']
    Serial_Number = json_data['Serial_Number']
    Mac_Address = json_data['Mac_Address']
    Communication_Frequency = json_data['Communication_Frequency']
    Installation_Date = json_data['Installation_Date']
    Write_Frequency = json_data['Write_Frequency']
    Write_Time = json_data['Write_Time']
    Reporting_Url = json_data['Reporting_Url']

    valid_input = Validate_Input(Name, Compressor_status, Fan_status, Temperature, Ip_Address, Serial_Number, Mac_Address, Communication_Frequency, Installation_Date, Write_Frequency, Write_Time, Reporting_Url)

    if (not valid_input):
        # Returning the HTTP code 400. Bad request
        return ('Invalid data, Please check the documentation', 400)
    
    Temperature_alert = '1' if Temperature > 80 else '0'
    Timestamp = str(time.strftime("%m/%d/%Y %H:%M:%S"))

    # Checking to see if the test value is passed to the API, If test is true, the testing database is used
    if "test" in json_data:
        test = json_data["test"]
    else:
        test = False

    db_context = open_connection(test)
    cur = db_context.cursor()

    # Executing the query
    cur.execute('SELECT * FROM public."Devices" WHERE "Mac_Address" = %s AND "Serial_Number" = %s', (Mac_Address, Serial_Number))

    # Fetching the result
    result_set_check = cur.fetchall()
    
    exists = False
    # Checking to see if the device exists
    if(result_set_check != []):
        exists = True

    if (exists):
        # Returning the HTTP code 204. Bad request
        return ('Device already exists', 204)

    Active = 'true'
    
    Compressor_status_string = str(Compressor_status)
    Fan_status_string = str(Fan_status)
    Temperature_string = str(Temperature)
    Communication_Frequency_string = str(Communication_Frequency)
    Write_Frequency_string = str(Write_Frequency)
    Write_Time_string = str(Write_Time)
    
    cur.execute('INSERT INTO public."Devices"("Name", "Compressor_status", "Fan_status", "Temperature_alert", "Temperature", "Ip_Address", "Serial_Number", "Mac_Address", "Communication_Frequency", "Installation_Date", "Write_Frequency", "Write_Time", "Reporting_Url", "Timestamp", "Active") VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s);',(Name, Compressor_status_string, Fan_status_string,Temperature_alert, Temperature_string, Ip_Address, Serial_Number, Mac_Address, Communication_Frequency_string, Installation_Date, Write_Frequency_string, Write_Time_string, Reporting_Url, Timestamp , Active))
    db_context.commit()

    # Closing the databse connection before returning the result
    close_connection(cur, db_context)

    # Return the Http 200 status to show a succcess status
    return ('', 200)
def write_immediate_api(request):
    """The Write Immidiate API is used to log each transaction to the database"""
    data = request.data
    json_data = json.loads(data)

    # Saving the parameters as string
    mac = json_data["mac"]
    serial = json_data["serial"]

    # Checking to see if the test value is passed to the API, If test is true, the testing database is used
    if "test" in json_data:
        test = json_data["test"]
    else:
        test = False

    valid_input = Validate_Input(json_data["mac"], json_data["serial"])

    if not valid_input:
        # Returning the HTTP code 204 because the server successfully processed the request, but is not returning any content.
        return ('', 204)

    # Appending the paramters to the query string
    db_context = open_connection(test)
    cur = db_context.cursor()

    # Executing the query
    cur.execute(
        'SELECT * FROM public."Devices" WHERE "Mac_Address" = %s AND "Serial_Number" = %s',
        (mac, serial))

    # Fetching the result
    result_set = cur.fetchall()
    if not result_set:
        # Returning the HTTP code 204 because the server successfully processed the request, but is not returning any content.
        close_connection(cur, db_context)
        return ('', 204)

    colnames = [desc[0] for desc in cur.description]
    device = result_set[0]
    # Saving the result as a key, value pair
    result = dict(zip(colnames, device))
    device_Id = str(result['Id'])

    valid_input = True

    status_at_event_comp = str(json_data["status_at_event_comp"])

    # status_at_event_comp can only accept 0 or 1.
    if int(status_at_event_comp) < 0 or int(status_at_event_comp) > 1:
        valid_input = False

    status_at_event_fan = str(json_data["status_at_event_fan"])

    # status_at_event_fan can only accept 0 or 1.
    if int(status_at_event_fan) < 0 or int(status_at_event_fan) > 1:
        valid_input = False

    status_after_event_comp = str(json_data["status_after_event_comp"])

    # status_after_event_comp can only accept 0 or 1.
    if int(status_after_event_comp) < 0 or int(status_after_event_comp) > 1:
        valid_input = False

    status_after_event_fan = str(json_data["status_after_event_fan"])

    # status_after_event_fan can only accept 0 or 1.
    if int(status_after_event_fan) < 0 or int(status_after_event_fan) > 1:
        valid_input = False

    restart_chk_comp = str(json_data["restart_chk_comp"])

    # restart_chk_comp can only accept 0 or 1.
    if int(restart_chk_comp) < 0 or int(restart_chk_comp) > 1:
        valid_input = False

    restart_chk_fan = str(json_data["restart_chk_fan"])

    # restart_chk_fan can only accept 0 or 1.
    if int(restart_chk_fan) < 0 or int(restart_chk_fan) > 1:
        valid_input = False

    Timestamp = str(time.strftime("%m/%d/%Y %H:%M:%S"))

    if valid_input:
        cur.execute(
            'INSERT INTO public."DeviceEvents" ("DeviceId", "Status_At_Event_Compressor", "Status_At_Event_Fan", "Status_After_Event_Compressor", "Status_After_Event_Fan", "Restart_Check_Compressor", "Restart_Check_Fan", "Timestamp") VALUES (%s, %s, %s, %s, %s, %s, %s, %s)',
            (device_Id, status_at_event_comp, status_at_event_fan,
             status_after_event_comp, status_after_event_fan, restart_chk_comp,
             restart_chk_fan, Timestamp))
        db_context.commit()

    # Closing the databse connection before returning the result
    close_connection(cur, db_context)

    if valid_input:
        # Return the Http 200 status to show a succcess status
        return ('', 200)
    else:
        # Return an Http 400 status to show a bad request because of invalid data
        return ('Invalid data, Please check the documentation', 400)
Esempio n. 7
0
def read_api(request):
    """The Read API returns the current status of a device"""

    # Starting a timer
    start = int(round(time.time() * 1000))
    
    # Reading the parameters from the body
    data = request.data
    json_data = json.loads(data)
    
    mac = json_data["mac"]
    serial =  json_data["serial"]

    valid_input = Validate_Input(json_data["mac"],json_data["serial"])

    if not valid_input:
        # Returning the HTTP code 204 because the server successfully processed the request, but is not returning any content.
        return ('', 204)

    # Checking to see if the test value is passed to the API, If test is true, the testing database is used
    if "test" in json_data:
        test = json_data["test"]
    else:
        test = False

    # Appending the paramters to the query string
    db_context = open_connection(test)
    cur = db_context.cursor()

    # Executing the query
    # pyscopg2 will sanitize your query
    cur.execute('SELECT * FROM public."Devices" WHERE "Mac_Address" = %s AND "Serial_Number" = %s', (str(mac), str(serial)))

    # Fetching the result
    result_set = cur.fetchall()
    result = []

    # Checking to see if we recieve any data
    if not result_set:
        # Returning the HTTP code 204 because the server successfully processed the request, but is not returning any content.
        close_connection(cur, db_context)
        return ('', 204)

    colnames = [desc[0] for desc in cur.description]
    device = result_set[0]

    # Saving the result as a key, value pair
    result = dict(zip(colnames,device))

    response = {}
    response['comm_freq'] = result['Communication_Frequency']

    # Passing the value of the Write_Frequency to the write_freq_display function in order to display the appropriate message
    response['write_freq'] = write_freq_display(result['Write_Frequency'])
    response['write_length_time'] = result['Write_Time']

    # Passing the value of the Compressor_status to the conpressor_status_display function in order to display the appropriate message
    response['demand_resp_code'] =  conpressor_status_display(result['Compressor_status']) #0=No event /1=Compressor Off (6min)/2=Compressor Off (12min)/ 3=Comp&Fan Off (12min)
    response['demand_resp_time'] = '' #time H:M:S

    if not test:
        response['time'] = time.strftime("%H:%M:%S") #current time
    
    response['reporting_url'] = result['Reporting_Url'] #url to report to. (If change, update Chip)
    response['mac'] = json_data["mac"]
    response['serial'] = json_data["serial"]
    
    # calculating the delay in milliseconds
    end = int(round(time.time() * 1000))
    if not test:
        response['delay'] = end - start #Delay in milli-seconds after the event.
    
    # Closing the databse connection before returning the result
    close_connection(cur, db_context)

    # Return the JSON object and the Http 200 status to show a success status
    return json.dumps(response),status.HTTP_200_OK
Esempio n. 8
0
def view_device_api(request):
    """The View Device API returns the current status of the device to load the dashboard"""
    customer_Id = request.args.get('customer_Id')
    device_Id = request.args.get('device_Id')
    test = False
    if not customer_Id and not device_Id:
        # Reading the parameters from the body
        data = request.data
        json_data = json.loads(data)

        # Saving the parameters as string
        customer_Id = str(json_data["customer_Id"])
        device_Id = str(json_data["device_Id"])

        # Checking to see if the test value is passed to the API, If test is true, the testing database is used
        if "test" in json_data:
            test = json_data["test"]
        else:
            test = False

    valid_input = Validate_Input(customer_Id, device_Id)

    if not valid_input:
        # Returning the HTTP code 204 because the server successfully processed the request, but is not returning any content.
        return ('', 204)

    # Opening the connection to the database
    db_context = open_connection(test)
    cur = db_context.cursor()

    # Executing the query
    cur.execute(
        'SELECT * FROM public."CustomerDevices" cp, public."Devices" p WHERE cp."DeviceId" = p."Id" AND cp."CustomerId" = %s AND p."Id" = %s',
        (customer_Id, device_Id))

    # Fetching the result
    result_set = cur.fetchall()
    result = []

    if not result_set:
        # Returning the HTTP code 204 because the server successfully processed the request, but is not returning any content.
        close_connection(cur, db_context)
        return ('', 204)

    colnames = [desc[0] for desc in cur.description]

    result = dict(zip(colnames, result_set[0]))
    response = {}

    if test:
        result['Timestamp'] = None

    response['Device_details'] = {
        'Device_Id': result['DeviceId'],
        'Device_Name': result['Name'],
        'Fan_status': result['Fan_status'],
        'Temperature_alert': result['Temperature_alert'],
        'Temperature': result['Temperature'],
        'Ip_Address': result['Ip_Address'],
        'Serial_Number': result['Serial_Number'],
        'Mac_Address': result['Mac_Address'],
        'Communication_Frequency': result['Communication_Frequency'],
        'Installation_Date': result['Installation_Date'],
        'Write_Frequency': result['Write_Frequency'],
        'Write_Time': result['Write_Time'],
        'Timestamp': result['Timestamp']
    }

    # Closing the databse connection before returning the result
    close_connection(cur, db_context)

    # Return the JSON object and the Http 200 status to show a success status
    return json.dumps(response), status.HTTP_200_OK
Esempio n. 9
0
def write_api(request):
    """The Write API updates the current state of the device in the database"""
    data = request.data
    json_data = json.loads(data)
    
    # Saving the parameters as string
    mac = json_data["mac"]
    serial = json_data["serial"]

    # Checking to see if the test value is passed to the API, If test is true, the testing database is used
    if "test" in json_data:
        test = json_data["test"]
    else:
        test = False

    valid_input = Validate_Input(mac, serial)

    if not valid_input:
        # Returning the HTTP code 204 because the server successfully processed the request, but is not returning any content.
        return ('', 204)


    db_context = open_connection(test)
    cur = db_context.cursor()

    # Executing the query
    cur.execute('SELECT * FROM public."Devices" WHERE "Mac_Address" = %s AND "Serial_Number" = %s', (mac, serial))

    # Fetching the result
    result_set = cur.fetchall()

    if (result_set == []):
        # Returning the HTTP code 204 because the server successfully processed the request, but is not returning any content.
        close_connection(cur, db_context)
        return ('', 204)
    
    # Setting a flag to check if the inputs are valid and within bounds before writing to the database
    valid_input = True

    Compressor_status = str(json_data["comp_status"])

    # Compressor_status can only accept 0 or 1.
    if int(Compressor_status) < 0 or int(Compressor_status) > 1:
        valid_input = False

    Fan_status = str(json_data["fan_status"])

    # Fan_status can only accept 0 or 1.
    if int(Fan_status) < 0 or int(Fan_status) > 1:
        valid_input = False

    Temperature_alert = str(json_data["temp_alert"])

    # Temperature_alert can only accept 0 or 1.
    if int(Temperature_alert) < 0 or int(Temperature_alert) > 1:
        valid_input = False

    Temperature = str(json_data["temp"])
    Timestamp = str(time.strftime("%m/%d/%Y %H:%M:%S"))
    Mac_Address = json_data["mac"]
    Serial_Number = json_data["serial"]

    if valid_input:
        cur.execute('UPDATE public."Devices" SET "Compressor_status"=%s, "Fan_status"=%s, "Temperature_alert"=%s, "Temperature"=%s, "Timestamp"=%s WHERE "Mac_Address" = %s AND "Serial_Number" = %s', (Compressor_status,Fan_status,Temperature_alert,Temperature,Timestamp,Mac_Address,Serial_Number))
        db_context.commit()

    # Closing the databse connection before returning the result
    close_connection(cur, db_context)

    if valid_input:
        # Return the Http 200 status to show a succcess status
        return ('', 200)
    else:
        # Return an Http 400 status to show a bad request because of invalid data
        return ('Invalid data, Please check the documentation', 400)
def view_device_logs_api(request):
    """The View Device Logs API returns the logs for a device"""

    # Reading the parameters from the argument
    device_Id = request.args.get('device_Id')
    from_date = request.args.get('from_date')
    to_date = request.args.get('to_date')
    test = False
    if device_Id == None:
        # Reading the parameters from the body
        data = request.data
        json_data = json.loads(data)

        # Saving the parameters as string
        device_Id = str(json_data["device_Id"])

        if from_date in json_data:
            from_date = str(json_data["from_date"])

        if to_date in json_data:
            to_date = str(json_data["to_date"])

        # Checking to see if the test value is passed to the API, If test is true, the testing database is used
        if "test" in json_data:
            test = json_data["test"]
        else:
            test = False

    # Opening the connection to the database
    db_context = open_connection(test)
    cur = db_context.cursor()

    valid_input = Validate_Input(device_Id)

    if not valid_input:
        # Returning the HTTP code 204 because the server successfully processed the request, but is not returning any content.
        return ('', 204)

    if (test):
        cur.execute(
            'SELECT * FROM public."DeviceEvents" e WHERE e."DeviceId" = %s AND e."Id"=1',
            (device_Id, ))
    else:
        cur.execute(
            'SELECT * FROM public."DeviceEvents" e WHERE e."DeviceId" = %s',
            (device_Id, ))

    # Fetching the result
    result_set = cur.fetchall()
    result = []

    if not result_set:
        # Returning the HTTP code 204 because the server successfully processed the request, but is not returning any content.
        close_connection(cur, db_context)
        return ('', 204)

    colnames = [desc[0] for desc in cur.description]

    for row in result_set:
        result.append(dict(zip(colnames, row)))

    response = []

    for data in result:
        add_to_result = True

        # Checking to see if it is the testing enviornment
        if not test:
            timestamp = data['Timestamp']
            if from_date and to_date:
                from_date_parse = from_date.split('-')  # YYYY MM DD
                to_date_parse = to_date.split('-')  # YYYY MM DD

                date_parse = timestamp.split('/')
                date_parse[2] = date_parse[2].split(' ')[0]  # MM DD YYYY

                # If the date lies inbetween the from and to date, TRUE is returned
                add_to_result = date_check(from_date_parse, to_date_parse,
                                           date_parse)
        else:
            timestamp = None

        # If true, the data is added to the response object
        if add_to_result:
            response.append({
                'Id':
                data['Id'],
                'Device_Id':
                data['DeviceId'],
                'Status_At_Event_Compressor':
                data['Status_At_Event_Compressor'],
                'Status_At_Event_Fan':
                data['Status_At_Event_Fan'],
                'Status_After_Event_Compressor':
                data['Status_After_Event_Compressor'],
                'Status_After_Event_Fan':
                data['Status_After_Event_Fan'],
                'Restart_Check_Compressor':
                data['Restart_Check_Compressor'],
                'Restart_Check_Fan':
                data['Restart_Check_Fan'],
                'Temperature':
                data['Temperature'],
                'Timestamp':
                timestamp
            })

    # Closing the databse connection before returning the result
    close_connection(cur, db_context)

    # Return the JSON object and the Http 200 status to show a success status
    return json.dumps(response), status.HTTP_200_OK