<html><head><meta name="color-scheme" content="light dark"></head><body><pre style="word-wrap: break-word; white-space: pre-wrap;"># Python imports
import time
import json

# Django imports
from django.shortcuts import render_to_response, render, redirect
from django.http import HttpResponse, HttpResponseNotFound
from django.http import JsonResponse

# LeakLess monitor imports
from Applications.Devices.models import *
from Applications.Measure.views import *
from Applications.Devices.Configuration.views import *
from Applications.Devices.views import *
from Applications.Users.views import *
from Applications.Measure.models import *

def alarm_profiles_view(request):
    if request.user.is_authenticated():

        device_list = Lldevicelist.objects.filter(loc_active=1)
        devices_treeview = []

        for device in device_list:
            if request.user.has_perm("DeviceList." + str(device.id)):
                devices_treeview.append(alarm_profiles_return_device_node(device))

        return render_to_response('alarm_profiles/alarm_profiles.html', {'devices_treeview': json.dumps(devices_treeview)}, RequestContext(request, processors=[general_context]))
    else:
        return redirect(reverse('login_page'))




def alarm_profiles_return_device_node(device):

    return_data={
        'text'                  : device.get_device_id() +" ["+device.get_device_identifier()+"]",
        'device_id'             : device.get_device_id(),
        'identifier'            : device.get_device_identifier(),
        'icon'                  : "glyphicon glyphicon-stop",
        'selectedIcon'          : "glyphicon glyphicon-stop",
        'showCheckbox'          : False,
        'backColor'             : "white",
        'selectable'            : True,
        'device_node'           : True,
        'alarm_profile_support' : False,
        'state': {
            'checked'           : False,
            'disabled'          : False,
            'expanded'          : False,
            'selected'          : False
        },
        'nodes'                 : []
    }

    if device.loc_type == 'PDL-AG':
        # TODO: provjeriti firmware uredaja
        firmware_info=device.get_device_version()
        if firmware_info is None or 'AP' not in firmware_info:
            return_data['alarm_profile_support']=False
        else:
            return_data['tags']=['Profile']
            return_data['alarm_profile_support']=True

    elif device.loc_type == 'PDL-HG':
        # TODO: provjeriti firmware uredaja
        firmware_info=device.get_device_version()
        if firmware_info is None or 'AP' not in firmware_info:
            return_data['alarm_profile_support']=False
        else:
            return_data['tags']=['Profile']
            return_data['alarm_profile_support']=True

    elif device.loc_type == 'MAG8000':
        return_data['tags']=[]
        return_data['selectable']=False
        return_data['state']['disabled']=True
        return_data['alarm_profile_support']=False

    elif device.loc_type == 'SOFREL':
        return_data['tags'] = []
        return_data['selectable'] = False
        return_data['state']['disabled'] = True
        return_data['alarm_profile_support'] = False

    elif device.loc_type == 'CSV':
        return_data['tags'] = []
        return_data['selectable'] = False
        return_data['state']['disabled'] = True
        return_data['alarm_profile_support'] = False
    else:
        return_data={}


    return return_data

def alarm_profiles_return_data(request):
    if request.user.is_authenticated():
        if request.method == 'GET':
            data_available = False
            data_date     = datetime.strptime(request.GET['date'], "%Y-%m-%d").date()
            device_id     = request.GET['device_id']

            device = devices_return_by_id(device_id)
            if device is None:
                return HttpResponseNotFound('Device not found')

            if device.loc_type == 'PDL-AG':
                return_data =  alarm_profiles_return_data_pdlag(device, data_date)
                if return_data is None:
                    return HttpResponseNotFound('Device not supported')
                else:
                    return JsonResponse(return_data)
            elif device.loc_type == 'PDL-HG':
                return_data = alarm_profiles_return_data_pdlhg(device, data_date)
                if return_data is None:
                    return HttpResponseNotFound('Device not supported')
                else:
                    return JsonResponse(return_data)
            else:
                return HttpResponseNotFound('Device not supported')

        else:
            return HttpResponse('Invalid method')

    else:
        return redirect(reverse('login_page'))

def alarm_profiles_return_data_pdlag(device, date):
    device_info = device.get_device_info()

    time_start = datetime(date.year, date.month, date.day, 0, 0, 0)
    time_end = datetime(date.year, date.month, date.day, 23, 59, 59)

    measurement_list = measure_get_measure_data(device, time_start, time_end)


    data_response = {
        'data_available': len(measurement_list)&gt;0,
        'time'          : [],
        'analog_ch1' : {
            'data'      : [],
            'label'     : device_info.get_ch1_voltage_unit()
        },
        'analog_ch2' : {
            'data'      : [],
            'label'     : device_info.get_ch2_voltage_unit()
        },
        'pulse_ch1' : {
            'data'      : [],
            'label'     : device_info.get_ch1_pulse_frequency_unit()
        },
        'pulse_ch2' : {
            'data'      : [],
            'label'     : device_info.get_ch2_pulse_frequency_unit()
        }
    }

    for measure in measurement_list:
        data_response['time'].append(str(measure.timestamp).replace("-", "/"))
        data_response['analog_ch1']['data'].append(measure.get_ch1_analog())
        data_response['analog_ch2']['data'].append(measure.get_ch2_analog())
        data_response['pulse_ch1']['data'].append(measure.get_ch1_pulse())
        data_response['pulse_ch2']['data'].append(measure.get_ch2_pulse())

    return data_response

def alarm_profiles_return_data_pdlhg(device, date):
    device_info = device.get_device_info()

    time_start = datetime(date.year, date.month, date.day, 0, 0, 0)
    time_end = datetime(date.year, date.month, date.day, 23, 59, 59)

    measurement_list = measure_get_measure_data(device, time_start, time_end)


    data_response = {
        'data_available': len(measurement_list)&gt;0,
        'time'          : [],
        'voltage_ch1' : {
            'data'      : [],
            'label'     : device_info.get_ch1_voltage_unit()
        },
        'voltage_ch2' : {
            'data'      : [],
            'label'     : device_info.get_ch2_voltage_unit()
        },
        'current_ch1' : {
            'data'      : [],
            'label'     : device_info.get_ch1_current_unit()
        },
        'current_ch2' : {
            'data'      : [],
            'label'     : device_info.get_ch2_current_unit()
        },
        'pulse_ch1' : {
            'data'      : [],
            'label'     : device_info.get_ch1_pulse_frequency_unit()
        },
        'pulse_ch2' : {
            'data'      : [],
            'label'     : device_info.get_ch2_pulse_frequency_unit()
        }
    }

    for measure in measurement_list:
        data_response['time'].append(str(measure.timestamp).replace("-", "/"))
        data_response['voltage_ch1']['data'].append(measure.get_ch1_analog_voltage())
        data_response['voltage_ch2']['data'].append(measure.get_ch2_analog_voltage())
        data_response['current_ch1']['data'].append(measure.get_ch1_analog_current())
        data_response['current_ch2']['data'].append(measure.get_ch2_analog_current())
        data_response['pulse_ch1']['data'].append(measure.get_ch1_pulse_frequency())
        data_response['pulse_ch2']['data'].append(measure.get_ch2_pulse_frequency())

    return data_response

def alarm_profiles_return_alarm_profiles(request):
    if request.user.is_authenticated():
        device_id           = request.GET.get('device_id')
        device              = devices_return_by_id(device_id)
        device_info         = device.get_device_info()

        if device.loc_type == 'PDL-AG':
            return_data = alarm_profiles_return_alarm_profiles_pdlag(device)
            if return_data is None:
                return HttpResponseNotFound('Device not supported')
            else:
                return render_to_response('alarm_profiles/alarm_profile_pdlag.html', return_data, RequestContext(request, processors=[general_context]))
        elif device.loc_type == 'PDL-HG':
            return_data = alarm_profiles_return_alarm_profiles_pdlhg(device)
            if return_data is None:
                return HttpResponseNotFound('Device not supported')
            else:
                return render_to_response('alarm_profiles/alarm_profile_pdlhg.html', return_data, RequestContext(request, processors=[general_context]))

        else:
            return HttpResponseNotFound('Device not supported')



    else:
        return redirect(reverse('login_page'))

def alarm_profiles_return_alarm_profiles_pdlag(device):
    firmware_info = device.get_device_version()
    if firmware_info is None or 'AP' not in firmware_info:
        return None

    return_data=[]
    node_info={
        'text'              : "Unknown",
        'icon'              : "glyphicon glyphicon-stop",
        'selectedIcon'      : "glyphicon glyphicon-stop",
        'showCheckbox'      : False,
        'selectable '       : True,
        'device_node'       : False,
        'state': {
            'checked'       : False,
            'disabled'      : False,
            'expanded'      : False,
            'selected'      : False
        },
        'tags'              : ['available'],
        'device_id'         : device.get_device_id(),
        'device_identifier' : device.get_device_identifier(),
    }

    try:
        alarm_profiles = LldevicePdlagAlarmProfile.objects.get(lldevicelist=device)
    except ObjectDoesNotExist:
        return None

    for x in range(0,8):
        node_info_ap=node_info.copy()
        profile_name_rem = alarm_profiles.get_profile_name_rem(x)
        profile_name_loc = alarm_profiles.get_profile_name_loc(x)
        profile_value_rem = alarm_profiles.get_profile_value_rem(x)
        profile_value_loc = alarm_profiles.get_profile_value_loc(x)

        if profile_name_rem != profile_name_loc:
            node_info_ap['text'] = 'Profile '+str(x)+' ['+profile_name_rem+'-&gt;'+profile_name_loc+']'
        else:
            node_info_ap['text'] = 'Profile '+str(x)+' ['+profile_name_loc+']'

        node_info_ap['value_rem'] = profile_value_rem
        node_info_ap['value_loc'] = profile_value_loc
        node_info_ap['number'] = x

        if profile_value_rem is None or profile_value_loc is None:
            node_info_ap['tags'] = ['Changed']
        elif profile_value_rem != profile_value_loc:
            node_info_ap['tags'] = ['Changed']
        else:
            node_info_ap['tags'] = ['Synced']

        return_data.append(node_info_ap)

    return {'device_id'                 : device.get_device_id(),
            'device_identifier'         : device.get_device_identifier(),
            'profiles_treeview'         : json.dumps(return_data)
            }

def alarm_profiles_return_alarm_profiles_pdlhg(device):
    firmware_info = device.get_device_version()
    if firmware_info is None or 'AP' not in firmware_info:
        return None

    return_data=[]
    node_info={
        'text'              : "Unknown",
        'icon'              : "glyphicon glyphicon-stop",
        'selectedIcon'      : "glyphicon glyphicon-stop",
        'showCheckbox'      : False,
        'selectable '       : True,
        'device_node'       : False,
        'state': {
            'checked'       : False,
            'disabled'      : False,
            'expanded'      : False,
            'selected'      : False
        },
        'tags'              : ['available'],
        'device_id'         : device.get_device_id(),
        'device_identifier' : device.get_device_identifier(),
    }

    try:
        alarm_profiles = LldevicePdlhgAlarmProfile.objects.get(lldevicelist=device)
    except ObjectDoesNotExist:
        return None

    for x in range(0,8):
        node_info_ap=node_info.copy()
        profile_name_rem = alarm_profiles.get_profile_name_rem(x)
        profile_name_loc = alarm_profiles.get_profile_name_loc(x)
        profile_value_rem = alarm_profiles.get_profile_value_rem(x)
        profile_value_loc = alarm_profiles.get_profile_value_loc(x)

        if profile_name_rem != profile_name_loc:
            node_info_ap['text'] = 'Profile '+str(x)+' ['+profile_name_rem+'-&gt;'+profile_name_loc+']'
        else:
            node_info_ap['text'] = 'Profile '+str(x)+' ['+profile_name_loc+']'

        node_info_ap['value_rem'] = profile_value_rem
        node_info_ap['value_loc'] = profile_value_loc
        node_info_ap['number'] = x

        if profile_value_rem is None or profile_value_loc is None:
            node_info_ap['tags'] = ['Changed']
        elif profile_value_rem != profile_value_loc:
            node_info_ap['tags'] = ['Changed']
        else:
            node_info_ap['tags'] = ['Synced']

        return_data.append(node_info_ap)

    return {'device_id'                 : device.get_device_id(),
            'device_identifier'         : device.get_device_identifier(),
            'profiles_treeview'         : json.dumps(return_data)
            }


def alarm_profiles_return_alarm_parameters(request):
    if request.user.is_authenticated():
        device_id           = request.GET.get('device_id')
        device              = devices_return_by_id(device_id)
        device_info         = device.get_device_info()

        if device.loc_type == 'PDL-AG':
            return_data = alarm_profiles_return_alarm_parameters_pdlag(device)
            if return_data is None:
                return HttpResponse('Error fetching parameters')
            else:
                return render_to_response('alarm_profiles/alarm_configuration_pdlag.html', return_data, RequestContext(request, processors=[general_context]))
        elif device.loc_type == 'PDL-HG':
            return_data = alarm_profiles_return_alarm_parameters_pdlhg(device)
            if return_data is None:
                return HttpResponse('Error fetching parameters')
            else:
                return render_to_response('alarm_profiles/alarm_configuration_pdlhg.html', return_data,
                                          RequestContext(request, processors=[general_context]))
        elif device.loc_type == 'MAG8000':
            return_data = {}
        elif device.loc_type == 'SOFREL':
            return_data = {}
        else:
            return HttpResponse('Error fetching parameters')

    else:
        return redirect(reverse('login_page'))


def alarm_profiles_return_alarm_parameters_pdlag(device):
    device_parameters = LldevicePdlagParameters.objects.get(lldevicelist=device)

    parameter_info = LldevicePdlagParameterinfo.objects.filter(visible__gte=1)

    param_list_analog1 = configuration_return_parameter_data(device_parameters, parameter_info, "ALARM_CH1P")
    param_list_analog2 = configuration_return_parameter_data(device_parameters, parameter_info, "ALARM_CH2P")
    param_list_pulse_f1 = configuration_return_parameter_data(device_parameters, parameter_info, "ALARM_CH1F")
    param_list_pulse_f2 = configuration_return_parameter_data(device_parameters, parameter_info, "ALARM_CH2F")
    param_list_digital1 = configuration_return_parameter_data(device_parameters, parameter_info, "ALARM_CH1D")
    param_list_digital2 = configuration_return_parameter_data(device_parameters, parameter_info, "ALARM_CH2D")

    alarm_day_list = ['None', 'AP0', 'AP1', 'AP2', 'AP3', 'AP4', 'AP5', 'AP6', 'AP7']


    alarm_day_values_ch1p_loc = device_parameters.get_loc_ap_voltage1()
    alarm_day_values_ch1p_rem = device_parameters.get_rem_ap_voltage1()

    alarm_day_values_ch2p_loc = device_parameters.get_loc_ap_voltage2()
    alarm_day_values_ch2p_rem = device_parameters.get_rem_ap_voltage2()

    alarm_day_values_ch1f_loc = device_parameters.get_loc_ap_pulse1()
    alarm_day_values_ch1f_rem = device_parameters.get_rem_ap_pulse1()

    alarm_day_values_ch2f_loc = device_parameters.get_loc_ap_pulse2()
    alarm_day_values_ch2f_rem = device_parameters.get_rem_ap_pulse2()

    firmware_info = device.get_device_version()
    if firmware_info is None or 'AP' not in firmware_info:
        alarm_profile_support = False
    else:
        alarm_profile_support = True

    return {'device_id'                 : device.get_device_id(),
            'device_identifier'         : device.get_device_identifier(),
            'alarm_profile_support'     : alarm_profile_support,
            'alarm_day_list'            : alarm_day_list,
            'alarm_day_values_ch1p_loc' : alarm_day_values_ch1p_loc,
            'alarm_day_values_ch1p_rem' : alarm_day_values_ch1p_rem,
            'alarm_day_values_ch2p_loc' : alarm_day_values_ch2p_loc,
            'alarm_day_values_ch2p_rem' : alarm_day_values_ch2p_rem,
            'alarm_day_values_ch1f_loc' : alarm_day_values_ch1f_loc,
            'alarm_day_values_ch1f_rem' : alarm_day_values_ch1f_rem,
            'alarm_day_values_ch2f_loc' : alarm_day_values_ch2f_loc,
            'alarm_day_values_ch2f_rem' : alarm_day_values_ch2f_rem,
            'param_list_analog1'        : param_list_analog1,
            'param_list_analog2'        : param_list_analog2,
            'param_list_pulsef1'        : param_list_pulse_f1,
            'param_list_pulsef2'        : param_list_pulse_f2,
            'param_list_digital1'       : param_list_digital1,
            'param_list_digital2'       : param_list_digital2,
            }

def alarm_profiles_return_alarm_parameters_pdlhg(device):
    device_parameters = LldevicePdlhgParameters.objects.get(lldevicelist=device)

    parameter_info = LldevicePdlhgParameterinfo.objects.filter(visible__gte=1)

    param_list_voltage1 = configuration_return_parameter_data(device_parameters, parameter_info, "ALARM_CH1V")
    param_list_voltage2 = configuration_return_parameter_data(device_parameters, parameter_info, "ALARM_CH2V")
    param_list_current1 = configuration_return_parameter_data(device_parameters, parameter_info, "ALARM_CH1C")
    param_list_current2 = configuration_return_parameter_data(device_parameters, parameter_info, "ALARM_CH2C")
    param_list_pulse_f1 = configuration_return_parameter_data(device_parameters, parameter_info, "ALARM_CH1P")
    param_list_pulse_f2 = configuration_return_parameter_data(device_parameters, parameter_info, "ALARM_CH2P")
    param_list_digital1 = configuration_return_parameter_data(device_parameters, parameter_info, "ALARM_CH1D")
    param_list_digital2 = configuration_return_parameter_data(device_parameters, parameter_info, "ALARM_CH2D")

    alarm_day_list = ['None', 'AP0', 'AP1', 'AP2', 'AP3', 'AP4', 'AP5', 'AP6', 'AP7']

    alarm_day_values_ch1v_loc = device_parameters.get_loc_ap_voltage1()
    alarm_day_values_ch1v_rem = device_parameters.get_rem_ap_voltage1()

    alarm_day_values_ch2v_loc = device_parameters.get_loc_ap_voltage2()
    alarm_day_values_ch2v_rem = device_parameters.get_rem_ap_voltage2()

    alarm_day_values_ch1c_loc = device_parameters.get_loc_ap_current1()
    alarm_day_values_ch1c_rem = device_parameters.get_rem_ap_current1()

    alarm_day_values_ch2c_loc = device_parameters.get_loc_ap_current2()
    alarm_day_values_ch2c_rem = device_parameters.get_rem_ap_current2()

    alarm_day_values_ch1p_loc = device_parameters.get_loc_ap_pulse1()
    alarm_day_values_ch1p_rem = device_parameters.get_rem_ap_pulse1()

    alarm_day_values_ch2p_loc = device_parameters.get_loc_ap_pulse2()
    alarm_day_values_ch2p_rem = device_parameters.get_rem_ap_pulse2()

    firmware_info = device.get_device_version()
    if firmware_info is None or 'AP' not in firmware_info:
        alarm_profile_support = False
    else:
        alarm_profile_support = True

    return {'device_id': device.get_device_id(),
            'device_identifier': device.get_device_identifier(),
            'alarm_profile_support': alarm_profile_support,
            'alarm_day_list': alarm_day_list,
            'alarm_day_values_ch1v_loc': alarm_day_values_ch1v_loc,
            'alarm_day_values_ch1v_rem': alarm_day_values_ch1v_rem,
            'alarm_day_values_ch2v_loc': alarm_day_values_ch2v_loc,
            'alarm_day_values_ch2v_rem': alarm_day_values_ch2v_rem,
            'alarm_day_values_ch1c_loc': alarm_day_values_ch1c_loc,
            'alarm_day_values_ch1c_rem': alarm_day_values_ch1c_rem,
            'alarm_day_values_ch2c_loc': alarm_day_values_ch2c_loc,
            'alarm_day_values_ch2c_rem': alarm_day_values_ch2c_rem,
            'alarm_day_values_ch1p_loc': alarm_day_values_ch1p_loc,
            'alarm_day_values_ch1p_rem': alarm_day_values_ch1p_rem,
            'alarm_day_values_ch2p_loc': alarm_day_values_ch2p_loc,
            'alarm_day_values_ch2p_rem': alarm_day_values_ch2p_rem,
            'param_list_ch1v': param_list_voltage1,
            'param_list_ch2v': param_list_voltage2,
            'param_list_ch1c': param_list_current1,
            'param_list_ch2c': param_list_current2,
            'param_list_ch1p': param_list_pulse_f1,
            'param_list_ch2p': param_list_pulse_f2,
            'param_list_ch1d': param_list_digital1,
            'param_list_ch2d': param_list_digital2,
            }

def alarm_profiles_save_profile(request):
    if request.user.is_authenticated():
        if request.is_ajax():
            if request.method == 'POST':
                return_data =json.loads(request.body)

                device_id                   = return_data['device_id']
                alarm_profile_data          = return_data['alarm_profile_data']
                alarm_profile_number        = return_data['alarm_profile_number']
                alarm_profile_resolution    = return_data['alarm_profile_resolution']
                alarm_profile_name          = return_data['alarm_profile_name']

                device = devices_return_by_id(device_id)

                data_response = {'ok': True, 'text': 'Finished ok'}

                if device_id is None:
                    data_response = { 'ok': False ,  'text': 'No device id selected'}
                    return JsonResponse(data_response)

                if alarm_profile_number is None or alarm_profile_number&lt;0 or alarm_profile_number&gt;7:
                    data_response = { 'ok': False ,  'text': 'Wrong alarm profile number'}
                    return JsonResponse(data_response)

                if alarm_profile_resolution is None or alarm_profile_resolution &lt; 0 or alarm_profile_resolution &gt; 255:
                    data_response = {'ok': False, 'text': 'Wrong alarm profile resolution'}
                    return JsonResponse(data_response)

                if alarm_profile_name is None or len(alarm_profile_name) &gt; 16 or len(alarm_profile_name) &lt; 1:
                    data_response = {'ok': False, 'text': 'Wrong input name'}
                    return JsonResponse(data_response)

                if alarm_profile_data is None or len(alarm_profile_data) != 24*4:
                    data_response = {'ok': False, 'text': 'Wrong alarm profile data'}
                    return JsonResponse(data_response)

                field_name_alarm = 'loc_ap'+str(alarm_profile_number)
                field_value_alarm =  alarm_profile_name+';'+str(alarm_profile_resolution)+';'+alarm_profile_data.upper()

                filed_name_last_profile_change = 'lastprofilechange'
                filed_value_last_profile_change= datetime.now()


                alarm_profile_dictionary = {field_name_alarm                : field_value_alarm,
                                            filed_name_last_profile_change  : filed_value_last_profile_change}

                if device.get_device_type() == 'PDL-AG':
                    LldevicePdlagAlarmProfile.objects.filter(lldevicelist=device).update(**alarm_profile_dictionary)
                elif device.get_device_type() == 'PDL-HG':
                    LldevicePdlhgAlarmProfile.objects.filter(lldevicelist=device).update(**alarm_profile_dictionary)

                #TODO: spremiti podatke u bazu
                return JsonResponse(data_response)

            else:
                return_data =json.loads(request.GET)

    else:
        return HttpResponse('Invalid user')


def alarm_profiles_save_parameters(request):
    if request.user.is_authenticated():
        if request.is_ajax():
            if request.method == 'POST':
                json_request =json.loads(request.body)

                device = devices_return_by_id(json_request['device_id'])

                if device is None:
                    data_response = { 'ok': False ,  'text': 'No device id selected'}
                    return JsonResponse(data_response)

                if device.loc_type == 'PDL-AG':
                    return_data = alarm_profiles_save_parameters_pdlag(device, json_request)
                elif device.loc_type == 'PDL-HG':
                    return_data = alarm_profiles_save_parameters_pdlhg(device, json_request)
                elif device.loc_type == 'MAG8000':
                    return_data = None
                else:
                    return_data = None

                if return_data is None:
                    return JsonResponse({ 'ok': False ,  'text': 'Error saving parameters'})


                if  len(return_data['fail_list']) &gt; 0:
                    user_action_data_short = "New unit save with " + str(len(return_data['fail_list'])) + " errors"
                    user_action_data_long = "Success: " + str(len(return_data['success_list'])) + " Fail: " + str(
                        len(return_data['fail_list'])) + " Params: " + ",".join(return_data['fail_list'])
                else:
                    user_action_data_short = "New unit save"
                    user_action_data_long = "Success: " + str(len(return_data['success_list'])) + " Fail: " + str(
                        len(return_data['fail_list'])) + " Params: " + ",".join(return_data['fail_list'])

                user_add_new_action(request.user.username, "UNIT_SAVE", user_action_data_short, user_action_data_long,
                                    device.get_device_id())

                data_response = {'ok': True, 'text': 'Ok'}
                return JsonResponse(data_response)

            else:
                return_data =json.loads(request.GET)

    else:
        return HttpResponse('Invalid user')


def alarm_profiles_save_parameters_pdlag(device, parsed_request):

    parameter_values = parsed_request['parameter_values']
    week_value_ch1p = parsed_request['week_value_ch1v']
    week_value_ch2p = parsed_request['week_value_ch2v']
    week_value_ch1f = parsed_request['week_value_ch1p']
    week_value_ch2f = parsed_request['week_value_ch2p']


    if week_value_ch1p &lt; 0 or week_value_ch1p &gt; 0xFFFFFFF or week_value_ch2p &lt; 0 or week_value_ch2p &gt; 0xFFFFFFF or week_value_ch1f &lt; 0 or week_value_ch1f &gt; 0xFFFFFFF or week_value_ch2f &lt; 0 or week_value_ch2f &gt; 0xFFFFFFF:
        return None

    parameter_dictionary = {}
    error_parameter_list = []
    success_parameter_list = []

    parameter_info_list = LldevicePdlagParameterinfo.objects.all()

    parameter_dictionary.update({'updateflag': '1'})  # Save the update flag
    # Spremanje parametara
    for parameter in parameter_values:
        parameter_name = parameter['name']
        parameter_value = parameter['value']
        if parameter_value is not None and parameter_name is not None:
            try:
                parameter_info = parameter_info_list.get(name=parameter_name)
            except ObjectDoesNotExist:
                continue
            if not (configuration_check_parameter_value(parameter_value, parameter_info)):
                error_parameter_list.append("1-" + parameter_name)
                continue

            d = {'loc_' + parameter_name.lower(): parameter_value}
            parameter_dictionary.update(d)
            success_parameter_list.append("1-" + parameter_name)
        else:
            error_parameter_list.append("0-" + parameter_name)

    # Spremanje week parametara
    parameter_dictionary.update({'loc_app1': week_value_ch1p})
    parameter_dictionary.update({'loc_app2': week_value_ch2p})
    parameter_dictionary.update({'loc_apf1': week_value_ch1f})
    parameter_dictionary.update({'loc_apf2': week_value_ch2f})

    LldevicePdlagParameters.objects.filter(lldevicelist=device).update(**parameter_dictionary)

    return{
        'success_list'  : success_parameter_list,
        'fail_list'     : error_parameter_list
    }


def alarm_profiles_save_parameters_pdlhg(device, parsed_request):

    parameter_values = parsed_request['parameter_values']
    week_value_ch1v = parsed_request['week_value_ch1v']
    week_value_ch2v = parsed_request['week_value_ch2v']
    week_value_ch1c = parsed_request['week_value_ch1c']
    week_value_ch2c = parsed_request['week_value_ch2c']
    week_value_ch1p = parsed_request['week_value_ch1p']
    week_value_ch2p = parsed_request['week_value_ch2p']


    if week_value_ch1v &lt; 0 or week_value_ch1v &gt; 0xFFFFFFF or week_value_ch2v &lt; 0 or week_value_ch2v &gt; 0xFFFFFFF or \
       week_value_ch1c &lt; 0 or week_value_ch1c &gt; 0xFFFFFFF or week_value_ch2c &lt; 0 or week_value_ch2c &gt; 0xFFFFFFF or \
       week_value_ch1p &lt; 0 or week_value_ch1p &gt; 0xFFFFFFF or week_value_ch2p &lt; 0 or week_value_ch2p &gt; 0xFFFFFFF:
        return None

    parameter_dictionary = {}
    error_parameter_list = []
    success_parameter_list = []

    parameter_info_list = LldevicePdlhgParameterinfo.objects.all()

    # Spremanje parametara
    parameter_dictionary.update({'updateflag': '1'}) # Save the update flag

    for parameter in parameter_values:
        parameter_name = parameter['name']
        parameter_value = parameter['value']
        if parameter_value is not None and parameter_name is not None:
            try:
                parameter_info = parameter_info_list.get(name=parameter_name)
            except ObjectDoesNotExist:
                continue
            if not (configuration_check_parameter_value(parameter_value, parameter_info)):
                error_parameter_list.append("1-" + parameter_name)
                continue

            d = {'loc_' + parameter_name.lower(): parameter_value}
            parameter_dictionary.update(d)
            success_parameter_list.append("1-" + parameter_name)
        else:
            error_parameter_list.append("0-" + parameter_name)

    # Spremanje week parametara
    parameter_dictionary.update({'loc_av1p': week_value_ch1v})
    parameter_dictionary.update({'loc_av2p': week_value_ch2v})
    parameter_dictionary.update({'loc_ac1p': week_value_ch1c})
    parameter_dictionary.update({'loc_ac2p': week_value_ch2c})
    parameter_dictionary.update({'loc_ap1p': week_value_ch1p})
    parameter_dictionary.update({'loc_ap2p': week_value_ch2p})

    LldevicePdlhgParameters.objects.filter(lldevicelist=device).update(**parameter_dictionary)

    return{
        'success_list'  : success_parameter_list,
        'fail_list'     : error_parameter_list
    }
def check_is_none(value):
    if value is None:
        value=0
    return value


def return_alarm_val(value):
    val =int(value, 16)
    if val&gt;=8:
        return val-7
    elif val&lt;8:
        return 0</pre></body></html>