penracourses/oef/views.py

from difflib import HtmlDiff, SequenceMatcher
from django.http import HttpResponse, JsonResponse
from django.shortcuts import get_object_or_404, render
from django.views.generic.edit import UpdateView, CreateView
from django.views.generic.detail import DetailView

from .models import Entry, Formats
# Create your views here.
from .tables import EntryTable
from .filters import EntryFilter
from django_filters.views import FilterView

from django_tables2 import SingleTableView, SingleTableMixin

class EntryUpdateView(UpdateView):
    model = Entry
    template_name = "oef/entry_update_view.html"
    fields = ['modality', 'exam_code', 'exam_name', 'questions', 'comments', "inactive"]

class EntryDetailView(DetailView):
    model = Entry
    template_name = "oef/entry_detail_view.html"

class FormatsCreateView(CreateView):
    model = Formats
    template_name_suffix = "_update_form"
    fields = ['name', 'format', 'inherits']

class FormatsUpdateView(UpdateView):
    model = Formats
    template_name_suffix = "_update_form"
    fields = ['name', 'format', 'specialties', 'inherits']

class EntryTableView(SingleTableMixin, FilterView):
    model = Entry
    table_class = EntryTable

    template_name = "oef/entry_table.html"

    filterset_class = EntryFilter

def formats_view(request):
    formats = Formats.objects.all()
    return render(request, "oef/formats_view.html", {"formats": formats})

def formats_apply(request, pk):
    format = get_object_or_404(Formats, pk=pk)

    search_text = format.get_format()

    entries = Entry.objects.filter(questions__icontains=search_text, inactive=False)

    entry_list = []
    for entry in entries:
        entry_list.append((entry, entry.questions.replace(search_text, "")))
    return render(request, "oef/formats_apply.html", {"format": format, "entry_list": entry_list, "entries": entries})

def entry_detail_formats(request, pk):
    entry = get_object_or_404(Entry, pk=pk)
    formats = Formats.objects.all()

    questions = entry.questions

    matching_formats = []
    for format in formats:
        if format.get_format() in questions:
            matching_formats.append(format)

    matching_formats = sorted(matching_formats, key=lambda x: len(x.get_format()))

    return render(request, "oef/entry_detail_formats.html", {"entry": entry, "matching_formats": matching_formats})

def replace_questions(request):
    if request.method == "POST":
        search = request.POST.get("search")
        replace = request.POST.get("replace")

        if not search or not replace:
            return HttpResponse("Please provide both search and replace values")

        if request.POST.get("exact", False):
            entries = Entry.objects.filter(questions=search, inactive=False)
        else:
            entries = Entry.objects.filter(questions__contains=search, inactive=False)

        for entry in entries:
            entry.questions = entry.questions.replace(search, replace)
            entry.save()

        return HttpResponse(f"{entries.count()} questions replaced")
    else:
        return render(request, "oef/replace_questions.html", {})

def questions(request):
    questions = set(Entry.objects.filter(inactive=False).values_list("questions", flat=True))

    questions = sorted(questions, key=lambda x: len(x))

    questions_and_formats = []

    for question in questions:
        try:
            format = Formats.objects.get(format=question)
        except Formats.DoesNotExist:
            format = None
        questions_and_formats.append((question, format))

    return render(request, "oef/questions.html", {"questions": questions, "questions_and_formats": questions_and_formats})

def entries_by_question(request):

    if request.method == "POST":
        question = request.POST.get("question")
        entries = Entry.objects.filter(questions=question, inactive=False)

        return render(request, "oef/entries_by_question.html", {"entries": entries})
    
    return HttpResponse("Please provide a question")

def entries_by_question_codes(request):

    if request.method == "POST":
        question = request.POST.get("question")
        entries = Entry.objects.filter(questions=question, inactive=False)

        return render(request, "oef/entries_by_question_codes.html", {"entries": entries})
    
    return HttpResponse("Please provide a question")

def questions_diff(request):
    if request.method == "POST":
        question1 = request.POST.get("question1", False)
        question2 = request.POST.get("question2", False)

        if not question1:
            question1 = request.POST.get("search")
            question2 = request.POST.get("replace")

        html = HtmlDiff().make_table(question1.split("\n"), question2.split("\n"))

        return HttpResponse(html)

    return HttpResponse("Please provide two questions")

def questions_sym(request):
    if request.method == "POST":
        question = request.POST.get("question")

        questions = set(Entry.objects.all().values_list("questions", flat=True))


        output = []
        for q in questions:
            ratio = SequenceMatcher(None, question, q).ratio()

            if ratio > 0.5:
                output.append((q, ratio))

        output = sorted(output, key=lambda x: x[1], reverse=True)

        return render(request, "oef/questions_sym.html", {"output": output})


    return HttpResponse("Please provide a question set")


def formats_save(request):

    if request.method == "POST":
        question = request.POST.get("question")
        format_name = request.POST.get("format_name")

        if not question:
            return HttpResponse("Please provide a question")

        if Formats.objects.filter(name=format_name).exists():
            return HttpResponse("Format name already exists")

        if Formats.objects.filter(format=question).exists():
            return HttpResponse("Format questions already exists")

        Formats.objects.create(name=format_name, format=question)
        
        return HttpResponse("Format saved")

    
    return HttpResponse("Please provide a question")