iotDashboard/iotDashboard/views.py

import redis
import json
from django.db import connections
from django.http import JsonResponse, HttpResponse
from django.shortcuts import render, redirect, get_object_or_404

from .forms import DeviceForm, SensorWithTypeForm
from iotDashboard.models import Device, Sensor

redis_client = redis.StrictRedis(host='10.10.0.1', port=6379, db=0)


def fetch_gpt_data():
    return redis_client.get("gpt").decode("utf-8").strip('b"').replace('\\"', '"').replace("\\n", "").replace("\\","").replace("\\u00b0", "°")

def chart(request):
    # Fetch devices and their related sensors
    devices = Device.objects.prefetch_related('sensors__type').all()  # Prefetch related sensors and their types

    # Create a list of devices and associated sensors
    devices_json = [
        {
            "name": device.name,
            "sensors": [{"id": sensor.id, "type": sensor.type.name} for sensor in device.sensors.all()]
        }
        for device in devices
    ]

    try:
        gpt_data = fetch_gpt_data()
        gpt = json.loads(gpt_data)
    except (redis.RedisError, json.JSONDecodeError) as e:
        gpt = {"summary": "Error fetching data", "recommendations": {}}
        print(f"Error fetching or parsing GPT data: {e}")

    context = {
        'devices_json': json.dumps(devices_json),  # Convert to a JSON string
        'gpt': gpt
    }

    return render(request, 'chart.html', context)

def fetch_device_data(request):
    device_name = request.GET.get('device', 'Livingroom')
    sensor_name = request.GET.get('sensor')  # This will be the actual sensor name
    start_date = request.GET.get('start_date')
    end_date = request.GET.get('end_date')

    # Log the parameters to ensure they are correct
    sensor_name = Sensor.objects.get(id=sensor_name).type.name

    print("Device Name:", device_name)
    print("Sensor Name:", sensor_name)  # Log sensor name
    print("Start Date:", start_date)
    print("End Date:", end_date)

    # Get the specific device by name
    device = get_object_or_404(Device, name=device_name)

    # Initialize lists to store times and values
    times = []
    values = []

    # Prepare SQL query and parameters for the device
    query = """
        SELECT time, metric, value
        FROM sensor_readings
        WHERE device_name = %s
    """
    params = [device.name]

    # If a specific sensor is specified, filter by that sensor name (converted to lowercase)
    if sensor_name:
        query += " AND metric = LOWER(%s)"  # Convert to lowercase for comparison
        params.append(sensor_name.lower())  # Convert sensor name to lowercase

    # Add time filtering to the query
    if start_date:
        query += " AND time >= %s::timestamptz"
        params.append(start_date)

    if end_date:
        query += " AND time <= %s::timestamptz"
        params.append(end_date)

    # Log the final query and params
    print("Final Query:", query)
    print("Params Before Execution:", params)

    # Fetch data from the database
    with connections["data"].cursor() as cursor:
        cursor.execute(query, params)
        rows = cursor.fetchall()

    # Log the number of rows returned
    print("Number of Rows Returned:", len(rows))

    # Process the results and extract times and values
    for row in rows:
        time, metric, value = row
        formatted_time = time.strftime('%Y-%m-%d %H:%M:%S')

        times.append(formatted_time)
        values.append(value)

    # If no data is found, return empty arrays
    if not times and not values:
        print("No data found for the specified device and sensor.")
        return JsonResponse({'times': [], 'values': []})

    # Return the response in the expected format
    return JsonResponse({'times': times, 'values': values})


def index(request):
    if request.user.is_authenticated:
        return redirect("/chart/")
    return HttpResponse("NOT AUTHENTICATED!!!")


def device_list(request):
    devices = Device.objects.all()
    return render(request, 'device_list.html', {'devices': devices})


def add_device(request):
    if request.method == 'POST':
        form = DeviceForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('device_list')
    else:
        form = DeviceForm()
    return render(request, 'device_form.html', {'form': form})


def edit_device(request, pk):
    device = get_object_or_404(Device, pk=pk)
    if request.method == 'POST':
        form = DeviceForm(request.POST, instance=device)
        if form.is_valid():
            form.save()
            return redirect('device_list')
    else:
        form = DeviceForm(instance=device)
    return render(request, 'device_form.html', {'form': form})


def delete_device(request, pk):
    device = get_object_or_404(Device, pk=pk)
    if request.method == 'POST':
        device.delete()
        return redirect('device_list')
    return render(request, 'device_confirm_delete.html', {'device': device})


def add_sensor_with_type(request):
    if request.method == 'POST':
        form = SensorWithTypeForm(request.POST)
        if form.is_valid():
            form.save()  # This will save both Sensor and SensorType as needed
            return redirect('device_list')  # Adjust this to your specific URL name
    else:
        form = SensorWithTypeForm()

    context = {'form': form}
    return render(request, 'sensor_form.html', context)


def logout_view(request):
    return redirect("/admin")


def devices_api(request):
    devices = list(Device.objects.all().values('name', 'sensors__type__name'))
    return JsonResponse(devices, safe=False)


def sensor_list(request, device_id):
    device = get_object_or_404(Device, id=device_id)
    sensors = device.sensors.all()  # Get sensors for this specific device
    return render(request, 'sensor_list.html', {'device': device, 'sensors': sensors})


def edit_sensor(request, pk):
    sensor = get_object_or_404(Sensor, pk=pk)
    if request.method == 'POST':
        form = SensorWithTypeForm(request.POST, instance=sensor)
        if form.is_valid():
            form.save()
            return redirect('sensor_list', device_id=sensor.device.pk)
    else:
        form = SensorWithTypeForm(instance=sensor)
    return render(request, 'sensor_form.html', {'form': form})


def delete_sensor(request, pk):
    sensor = get_object_or_404(Sensor, pk=pk)
    if request.method == 'POST':
        device_id = sensor.device.pk
        sensor.delete()
        return redirect('sensor_list', device_id=device_id)
    return render(request, 'sensor_confirm_delete.html', {'sensor': sensor})


def add_sensor(request, device_id):
    device = get_object_or_404(Device, pk=device_id)
    if request.method == 'POST':
        form = SensorWithTypeForm(request.POST)
        if form.is_valid():
            sensor = form.save(commit=False)
            sensor.device = device  # Associate the sensor with the device
            sensor.save()
            return redirect('device_list')  # Redirect to device list or appropriate view
    else:
        form = SensorWithTypeForm()

    return render(request, 'sensor_form.html', {'form': form, 'device': device})