digest_app/module_auth/views.py

import logging

from django.db.models import Q, Prefetch
from django.contrib import messages
from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.views import LogoutView
from django.contrib.auth.forms import PasswordResetForm
from django.contrib.auth.mixins import LoginRequiredMixin
from django.contrib.auth.views import (
    LoginView,
    PasswordResetCompleteView,
    PasswordResetConfirmView,
    PasswordResetDoneView,
    PasswordResetView,
)
from django.shortcuts import render, redirect, get_object_or_404
from django.urls import reverse_lazy
from django.views import generic
from .forms import LoginForm
from module_iam.models import IAmPrincipal
from module_activity.models import PrincipalHealthData, Intolerance, Symptoms, PastTreatment, ChronicCondition
from django_datatables_view.base_datatable_view import BaseDatatableView

from module_project import constants

logger = logging.getLogger(__name__)

class AdminLoginView(generic.View):
    template_name = "module_auth/login.html"
    form_class = LoginForm
    success_url = reverse_lazy("module_iam:dashboard")
    error_url = reverse_lazy("module_auth:login")
    success_message = constants.LOGIN_SUCCESS
    error_message = constants.INVALID_EMAIL_PASSWORD

    def get(self, request):
        form = self.form_class()

        return render(request, self.template_name, context={"form": form})

    def post(self, request):
        form = self.form_class(data=request.POST)
        context = {"form": form}
        if not form.is_valid():
            messages.error(request, constants.INVALID_EMAIL_PASSWORD)
            return render(request, self.template_name, context=context)

        email = form.cleaned_data['email']
        password = form.cleaned_data['password']

        user = authenticate(request, email=email, password=password)
        if user is None:
            messages.error(request, constants.INVALID_EMAIL_PASSWORD)
            return render(request, self.template_name, context=context)

        login(request, user)
        logging.info(f"User {user.email} logged in.")

        return redirect(self.success_url)


class AdminLogoutView(LogoutView):
    next_page = reverse_lazy("module_auth:login")
    
class CustomPasswordResetView(PasswordResetView):
    form_class = PasswordResetForm
    template_name = "module_auth/password_reset_form.html"
    email_template_name = "module_auth/password_reset_email_template.html"
    success_url = reverse_lazy("module_auth:password_reset_done")


class CustomPasswordResetDoneView(PasswordResetDoneView):
    template_name = "module_auth/password_reset_done.html"


class UserDashView(LoginRequiredMixin, generic.TemplateView):
    page_name = None
    resource = None
    action = None
    template_name = "module_auth/users_list.html"
    model = IAmPrincipal
    context_objext_name = "obj"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context["page_name"] = self.page_name
        return context


class UserListJson(BaseDatatableView):
    model = IAmPrincipal
    columns = ["id", "first_name", "email", "phone_no", "date_of_birth", "is_active"]
    order_columns = ["id", "first_name", "email", "phone_no", "date_of_birth", "is_active"]

    def filter_queryset(self, qs):
        print(f"request is {self.request.GET}")
        search_value = self.request.GET.get("search[value]", None)
        if search_value:
            # print(f"isdiget {search_value.isdigit()}")
            # if search_value.isdigit():
            #     qs = qs.filter(Q(id=search_value))

            qs = qs.filter(
                Q(id__icontains=search_value)
                | Q(first_name__icontains=search_value)
                | Q(email__icontains=search_value)
                | Q(date_of_birth__icontains=search_value)
                | Q(phone_no__icontains=search_value)
            )

        for column in self.columns:
            search_value = self.request.GET.get(f'columns[{self.columns.index(column)}][search][value]', None)
            if search_value:
                qs = qs.filter(**{f"{column}__icontains": search_value})

        return qs


class UserRecordView(LoginRequiredMixin, generic.View):
    page_name = None
    resource = None
    action = None
    model = IAmPrincipal
    template_name = "module_auth/user_view.html"

    def get(self, request, id):
        # Retrieve the IAmPrincipal instance
        principal_instance = get_object_or_404(IAmPrincipal, id=id)

        # Prefetch related Intolerance objects for the principal
        intolerance_prefetch = Prefetch(
            "intolerance_principal",
            queryset=Intolerance.objects.filter(principal=principal_instance),
            to_attr="intolerance_data",
        )

        symptom_prefetch = Prefetch(
            "symptoms_principal",
            queryset=Symptoms.objects.filter(principal=principal_instance),
            to_attr="symptoms_data",
        )

        pasttreatment_prefetch = Prefetch(
            "pasttreatment_principal",
            queryset=PastTreatment.objects.filter(principal=principal_instance),
            to_attr="pasttreatment_data",
        )

        chronic_prefetch = Prefetch(
            "chronic_principal",
            queryset=ChronicCondition.objects.filter(principal=principal_instance),
            to_attr="chronic_data",
        )

        # Now fetch the principal instance with prefetches
        obj = IAmPrincipal.objects.prefetch_related(
            intolerance_prefetch,
            symptom_prefetch,
            pasttreatment_prefetch,
            chronic_prefetch
        ).get(id=id)

        print(f"prefetch datatas")
        for data in obj.chronic_data:
            print(f"data is {data.name, data.duration}")

        # Render the template with the principal instance and related data
        return render(request, self.template_name, {'obj': obj})




























class CustomPasswordResetConfirmView(PasswordResetConfirmView):
    template_name = "module_auth/password_reset_confirm.html"
    success_url = reverse_lazy("module_auth:password_reset_complete")


class CustomPasswordResetCompleteView(PasswordResetCompleteView):
    template_name = "module_auth/password_reset_complete.html"