views.py

import mimetypes
import os
import datetime

from django.conf import settings
from django.contrib import messages
from django.contrib.auth.models import AnonymousUser
from django.core.exceptions import PermissionDenied, ValidationError
from django.db.models import Q, Count
from django.http import Http404, HttpResponse, HttpResponseRedirect, JsonResponse
from django.urls import reverse
from django.shortcuts import get_object_or_404, redirect
from django.template import loader
from django.views import defaults
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from django.views.generic import TemplateView
from administration.models import VerificationReport
from app.forms import SuntingProfilForm, UploadMateriForm, RatingContributorForm
from app.models import (
    Category,
    Comment,
    Materi,
    Like,
    ViewStatistics,
    DownloadStatistics,
    ReqMaterial,
    Rating,
    RatingContributor,
)
from app.utils.fileManagementUtil import get_random_filename, remove_image_exifdata
from authentication.models import User
import django
import pandas as pd
from io import BytesIO
from pydrive.auth import GoogleAuth
from pydrive.drive import GoogleDrive
from pydrive.auth import AuthenticationRejected
from django.contrib.auth.views import PasswordChangeForm
from django.urls import reverse_lazy
from django.contrib.auth.views import PasswordChangeView
from django.shortcuts import render


def permission_denied(request, exception, template_name="error_403.html"):
    return defaults.permission_denied(request, exception, template_name)


class DaftarKatalog(TemplateView):
    paginate_by = 2
    template_name = "app/katalog_materi.html"

    def get_context_data(self, **kwargs):
        return super().get_context_data(**kwargs)

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        context["kategori_list"] = Category.objects.all()

        lstMateri = Materi.objects.filter(status="APPROVE").order_by("date_modified")
        url = ""

        getSearch = request.GET.get("search")
        if getSearch:
            url = url + "&search={0}".format(getSearch)
            lstMateri = (
                lstMateri.search(getSearch)
                .filter(
                    Q(author__icontains=getSearch)
                    | Q(uploader__name__icontains=getSearch)
                    | Q(descriptions__icontains=getSearch)
                    | Q(publisher__icontains=getSearch)
                )
                .distinct()
            )

        getKategori = request.GET.get("kategori")
        if getKategori:
            url = url + "&kategori={0}".format(getKategori)
            kategori = Category.objects.get(pk=getKategori)
            lstMateri = lstMateri.filter(categories=kategori.pk)

        getSort = request.GET.get("sort")
        if getSort:
            url = url + "&sort={0}".format(getSort)
            if getSort == "judul":
                lstMateri = lstMateri.order_by("title")
            elif getSort == "penulis":
                lstMateri = lstMateri.order_by("author")
            elif getSort == "pengunggah":
                lstMateri = lstMateri.order_by("uploader")
            elif getSort == "terbaru":
                lstMateri = lstMateri.order_by("-date_created")
            elif getSort == "terlama":
                lstMateri = lstMateri.order_by("date_created")
            elif getSort == "terpopuler":
                lstMateri = lstMateri.annotate(count=Count("like__id")).order_by("-count")

        context["materi_list"] = lstMateri
        paginator = Paginator(context["materi_list"], 15)
        page_number = request.GET.get("page")
        page_obj = paginator.get_page(page_number)
        context["materi_list"] = page_obj

        context["url"] = url
        return self.render_to_response(context=context)


class KatalogPerKontributorView(TemplateView):
    template_name = "app/katalog_kontri.html"

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        contributor = get_object_or_404(User, email=kwargs["email"])
        context["contributor"] = contributor
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)

        materi_list = Materi.objects.filter(status="APPROVE", uploader=context["contributor"]).order_by(
            "date_modified"
        )

        paginator = Paginator(materi_list, 15)
        page_number = request.GET.get("page")
        materi_list_by_page = paginator.get_page(page_number)
        context["materi_list"] = materi_list_by_page
        contributor = get_object_or_404(User, email=kwargs["email"])
        context["form_rating"] = RatingContributorForm(initial={"user": contributor})
        return self.render_to_response(context=context)

    def post(self, request, *args, **kwargs):
        data = RatingContributorForm(request.POST)
        if data.is_valid():
            data.save()
        return redirect("katalog-per-kontributor", email=kwargs["email"])


class DetailMateri(TemplateView):
    template_name = "app/detail_materi.html"

    def get_context_data(self, **kwargs):
        context = super(DetailMateri, self).get_context_data(**kwargs)
        if not self.request.session or not self.request.session.session_key:
            self.request.session.save()
        materi = get_object_or_404(Materi, pk=kwargs["pk"])
        context["session_id"] = self.request.session.session_key
        context["materi_data"] = materi
        context["report"] = VerificationReport.objects.filter(materi=materi)
        context["has_liked"] = Like.objects.filter(materi=materi, session_id=self.request.session.session_key).exists()
        publishedDate = ""
        if materi.published_date == None:
            publishedDate = "n.d"
        else:
            publishedDate = materi.published_date.strftime("%Y-%m-%d %H:%M")
        citationAPA = materi.author + " . (" + publishedDate + ") . " + materi.title + " . " + materi.publisher
        context["citationAPA"] = citationAPA
        context["citationIEEE"] = get_citation_ieee(self.request, materi)
        context["materi_rating_score"] = 0

        if self.request.user.is_authenticated:
            materi_rating = Rating.objects.filter(materi=materi, user=self.request.user).first()
            if materi_rating is not None:
                context["materi_rating_score"] = materi_rating.score

        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        query_set_for_comment = Comment.objects.filter(materi=context["materi_data"])
        context["comment_data"] = query_set_for_comment
        return self.render_to_response(context=context)

    def get_user_name(self, request):
        user_name = ""
        if isinstance(request.user, AnonymousUser):
            user_name = "Anonim"
        elif request.user.is_admin:
            user_name = "Admin"
        elif request.user.is_contributor:
            user_name = request.user.name
        return user_name

    def post(self, request, *args, **kwargs):
        commentText = request.POST.get("comment", None)
        if commentText == None or commentText == "":
            context = self.get_context_data(*args, **kwargs)
            context["error_message"] = "Anda belum menuliskan komentar"
            context["materi_data"] = get_object_or_404(Materi, pk=kwargs["pk"])
            query_set_for_comment = Comment.objects.filter(materi=context["materi_data"])
            context["comment_data"] = query_set_for_comment
            return self.render_to_response(context=context)

        materi = get_object_or_404(Materi, pk=kwargs["pk"])
        user_obj = request.user if request.user.is_authenticated else None
        comment = Comment.objects.create(
            comment=commentText, username=self.get_user_name(request), materi=materi, user=user_obj
        )
        comment.save()
        return HttpResponseRedirect(request.path)


def toggle_like(request):
    if request.method == "POST":
        materi_id = request.POST.get("materi_id", None)
        session_id = request.POST.get("session_id", None)
        if materi_id is None or session_id is None:
            return JsonResponse({"success": False, "msg": "Missing parameter"})
        materi = get_object_or_404(Materi, pk=materi_id)
        has_liked = Like.objects.filter(materi=materi, session_id=session_id).exists()
        if has_liked:
            like = get_object_or_404(Like, materi=materi, session_id=session_id)
            like.delete()
            return JsonResponse({"success": True, "liked": True})
        else:
            Like(materi=materi, session_id=session_id).save()
            return JsonResponse({"success": True, "liked": False})
    else:
        return JsonResponse({"success": False, "msg": "Unsuported method"})


def delete_comment(request, pk_materi, pk_comment):
    comment = get_object_or_404(Comment, pk=pk_comment)
    url = "/materi/" + str(pk_materi) + "/"
    comment.delete()
    return HttpResponseRedirect(url)


def get_citation_ieee(request, materi):
    current_date = datetime.datetime.now()
    current_day = str(current_date.day)
    current_month = current_date.strftime("%b")
    current_year = str(current_date.year)
    published_date = ""
    if materi.published_date == None:
        published_date = "n.d"
    else:
        published_date = materi.published_date.strftime("%Y")

    author_list = materi.author.split(",")
    author_list_abbrv = ""
    for author_name in author_list:
        author_name_split = author_name.split(" ")
        author_name_abbrv = ""
        for j, name in enumerate(author_name_split):
            if j < (len(author_name_split) - 1):
                abbrv_name = name[0].upper()
                author_name_abbrv = author_name_abbrv + abbrv_name + ". "
            else:
                author_name_abbrv = author_name_abbrv + name
        author_list_abbrv = author_list_abbrv + author_name_abbrv + ", "

    citation_result = (
        author_list_abbrv
        + materi.title
        + ". "
        + materi.publisher
        + ", "
        + published_date
        + ". "
        + "Accessed on: "
        + current_month
        + ". "
        + current_day
        + ", "
        + current_year
        + ". [Online]. "
        + "Available: "
        + request.build_absolute_uri()
    )
    return citation_result


def add_rating_materi(request):
    if request.method == "POST" and request.user.is_authenticated:

        materi_id = request.POST.get("materi_id", None)
        rating_score = request.POST.get("rating_score", None)

        if materi_id is None or rating_score is None:
            return JsonResponse({"success": False, "msg": "Missing param"}, status=422)
        try:
            rating_score = int(rating_score)
        except ValueError:
            return JsonResponse({"success": False, "msg": "rating_score must be an integer"}, status=422)

        try:
            materi_id = int(materi_id)
        except ValueError:
            return JsonResponse({"success": False, "msg": "materi_id must be an integer"}, status=422)

        if rating_score not in range(1, 6):
            return JsonResponse({"success": False, "msg": "Rating must be an integer from 1 to 5"}, status=422)

        materi = Materi.objects.filter(pk=materi_id).first()

        if materi is None:
            return JsonResponse({"success": False, "msg": "Materi does not exist"}, status=422)

        if Rating.objects.filter(materi=materi, user=request.user).first() is not None:
            return JsonResponse({"success": False, "msg": "Rating already exist"}, status=409)

        Rating(materi=materi, user=request.user, score=rating_score).save()
        return JsonResponse(
            {"success": True, "msg": "Rating successfully created", "rating_score": rating_score}, status=201
        )
    return JsonResponse({"success": False, "msg": "Forbidden"}, status=403)


def download_materi(request, pk):
    materi = get_object_or_404(Materi, pk=pk)
    path = materi.content.path
    file_path = os.path.join(settings.MEDIA_ROOT, path)
    if os.path.exists(file_path):
        try:
            mimetype = mimetypes.guess_type(file_path)
            with open(file_path, "rb") as fh:
                response = HttpResponse(fh.read(), content_type=mimetype[0])
                response["Content-Disposition"] = "attachment; filename=" + os.path.basename(file_path)
                if request.user.is_authenticated:
                    DownloadStatistics(materi=materi, downloader=request.user).save()
                else:
                    downloaded_materi = DownloadStatistics.objects.create(materi=materi)
                    if "downloaded_materi" not in request.session:
                        request.session["downloaded_materi"] = []
                    request.session["downloaded_materi"].append(downloaded_materi.pk)
                    request.session.modified = True
                return response
        except Exception as e:
            raise Http404("File tidak dapat ditemukan.")
    else:
        raise Http404("File tidak dapat ditemukan.")


def view_materi(request, pk):
    materi = get_object_or_404(Materi, pk=pk)
    path = materi.content.path
    file_path = os.path.join(settings.MEDIA_ROOT, path)
    if os.path.exists(file_path):
        mimetype = mimetypes.guess_type(file_path)
        try:
            with open(file_path, "rb") as fh:
                response = HttpResponse(fh.read(), content_type=mimetype[0])
                response["Content-Disposition"] = "inline; filename=" + os.path.basename(file_path)
                ViewStatistics(materi=materi).save()
                return response
        except Exception as e:
            raise Http404("File tidak dapat ditemukan.")
    else:
        raise Http404("File tidak dapat ditemukan.")


class UploadMateriView(TemplateView):
    template_name = "unggah.html"
    context = {}

    def get_context_data(self, **kwargs):
        context = super(UploadMateriView, self).get_context_data(**kwargs)
        return context

    def post(self, request, *args, **kwargs):
        if request.user.is_authenticated == False or not request.user.is_contributor:
            raise PermissionDenied(request)
        form = UploadMateriForm(request.POST, request.FILES)
        if form.is_valid():
            materi = form.save(commit=False)
            materi.uploader = request.user
            konten = form.cleaned_data["content"]
            try:
                self.validate_file_extension(konten)
            except ValidationError:
                messages.error(request, "Materi gagal diunggah, format file tidak sesuai")
                return HttpResponseRedirect("/unggah/")
            materi.save()
            kateg = form.cleaned_data["categories"]
            for i in kateg:
                materi.categories.add(i)
            messages.success(request, "Materi berhasil diunggah, periksa riwayat unggah anda")
            return HttpResponseRedirect("/unggah/")
        else:
            context = self.get_context_data(**kwargs)
            context["form"] = form
            messages.error(request, "Terjadi kesalahan pada pengisian data")
            return self.render_to_response(context)

    def get(self, request, *args, **kwargs):
        if request.user.is_authenticated == False or not request.user.is_contributor:
            raise PermissionDenied(request)

        context = self.get_context_data(**kwargs)
        context["form"] = UploadMateriForm
        return self.render_to_response(context)

    def validate_file_extension(self, value):
        ext = os.path.splitext(value.name)[1]  # [0] returns path+filename
        valid_extensions = [".pdf", ".doc", ".docx", ".jpg", ".png", ".xlsx", ".xls", ".mp4", ".mp3"]
        if not ext.lower() in valid_extensions:
            raise ValidationError("Unsupported file extension.")


class UploadMateriHTML(TemplateView):
    template_name = "unggah.html"
    context = {}

    def get_template_names(self):
        if self.request.path == "/unggah/":
            template_name = "unggah.html"
        return template_name


class UploadMateriExcelView(TemplateView):
    template_name = "unggah_excel.html"
    context = {}

    def get_template_names(self):
        if self.request.path == "/unggah_excel/":
            template_name = "unggah_excel.html"
        return template_name

    def get(self, request, *args, **kwargs):

        if "template" in self.request.GET:

            data_frame = pd.DataFrame(
                {"Title": [], "Author": [], "Publisher": [], "Categories": [], "Description": [],}
            )

            with BytesIO() as b:
                writer = pd.ExcelWriter(b, engine="xlsxwriter")  # pylint: disable=abstract-class-instantiated
                data_frame.to_excel(writer, index=0)
                writer.save()
                response = HttpResponse(
                    b.getvalue(), content_type="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
                )

                response["Content-Disposition"] = "attachment; filename=template.xlsx"

                return response

        else:
            context = self.get_context_data(**kwargs)
            return self.render_to_response(context)

    def post(self, request, *args, **kwargs):
        excel_file = request.FILES["excel"]
        excel = pd.read_excel(excel_file)

        row, lines = excel.shape
        categories = Category.objects.all()

        field_length = {
            "title": 50,
            "author": 30,
            "publisher": 30,
        }

        message = None

        # First pass, validate input
        for i in range(row):

            # Validate Categories
            for c in excel["Categories"][i].split(","):
                sel_cat = categories.filter(name=c)
                if sel_cat.count() == 0:
                    message = f"Kategori %s tidak ditemukan" % c
                    break

            if len(excel["Title"][i]) > field_length["title"]:
                message = f"Title maksimal %d karakter" % field_length["title"]

            if len(excel["Author"][i]) > field_length["author"]:
                message = f"Author maksimal %d karakter" % field_length["author"]

            if len(excel["Publisher"][i]) > field_length["publisher"]:
                message = f"Publisher maksimal %d karakter" % field_length["publisher"]

            if message != None:
                break

        if message != None:
            messages.error(request, message)
            return HttpResponseRedirect("/unggah_excel/")

        # Second pass, save data
        with django.db.transaction.atomic():
            for i in range(row):
                materi = Materi(
                    title=excel["Title"][i],
                    author=excel["Author"][i],
                    publisher=excel["Publisher"][i],
                    descriptions=excel["Description"][i],
                    uploader=request.user,
                )
                materi.save()

                for c in excel["Categories"][i].split(","):
                    materi.categories.add(categories.get(name=c))

        messages.success(request, "Materi berhasil diunggah")

        return HttpResponseRedirect("/unggah_excel/")


class DashboardKontributorView(TemplateView):
    template_name = "dashboard.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_authenticated or not request.user.is_contributor:
            raise PermissionDenied(request)
        return super(DashboardKontributorView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(DashboardKontributorView, self).get_context_data(**kwargs)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        current_user = self.request.user
        materi_list = current_user.materi_set.all()
        context["materi_list"] = materi_list
        return self.render_to_response(context)


class ProfilAdminView(TemplateView):
    template_name = "profil-admin.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_authenticated or not request.user.is_admin:
            raise PermissionDenied(request)
        return super(ProfilAdminView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(ProfilAdminView, self).get_context_data(**kwargs)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        current_user = self.request.user
        context["user"] = current_user
        return self.render_to_response(context)


class ProfilKontributorView(TemplateView):
    template_name = "profil.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_authenticated or not request.user.is_contributor:
            raise PermissionDenied(request)
        return super(ProfilKontributorView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(ProfilKontributorView, self).get_context_data(**kwargs)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        current_user = self.request.user
        context["user"] = current_user
        return self.render_to_response(context)


class SuntingProfilView(TemplateView):
    template_name = "sunting.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_authenticated or not request.user.is_contributor:
            raise PermissionDenied(request)
        return super(SuntingProfilView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(SuntingProfilView, self).get_context_data(**kwargs)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)

        current_user = self.request.user
        context["user"] = current_user

        context["form"] = SuntingProfilForm(instance=current_user)
        return self.render_to_response(context)

    def post(self, request, *args, **kwargs):
        if request.user.is_authenticated == False:
            raise PermissionDenied(request)

        current_user = self.request.user

        form = SuntingProfilForm(request.POST, request.FILES, instance=current_user)
        if form.is_valid():
            current_user.default_profile_picture = True

            # Removing exifdata from profile picture on upload
            if request.FILES:
                f_name = request.FILES["profile_picture"].name
                f_name = get_random_filename(f_name)
                f_path = settings.MEDIA_ROOT + "/" + f_name
                request.FILES["profile_picture"].name = f_name

                form = SuntingProfilForm(request.POST, request.FILES, instance=current_user)
                form.save()

                remove_image_exifdata(f_path)
            else:
                form.save()
            return HttpResponseRedirect("/profil/")
        else:
            context = self.get_context_data(**kwargs)
            context["form"] = form
            return self.render_to_response(context)


class SuntingProfilAdminView(TemplateView):
    template_name = "sunting_admin.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_admin:
            raise PermissionDenied(request)
        return super(SuntingProfilAdminView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(SuntingProfilAdminView, self).get_context_data(**kwargs)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)

        current_user = self.request.user
        context["user"] = current_user

        context["form"] = SuntingProfilForm(instance=current_user)
        return self.render_to_response(context)

    def post(self, request, *args, **kwargs):
        if request.user.is_authenticated == False:
            raise PermissionDenied(request)

        current_user = self.request.user

        form = SuntingProfilForm(request.POST, request.FILES, instance=current_user)
        if form.is_valid():
            current_user.default_profile_picture = True

            # Removing exifdata from profile picture on upload
            if request.FILES:
                f_name = request.FILES["profile_picture"].name
                f_name = get_random_filename(f_name)
                f_path = settings.MEDIA_ROOT + "/" + f_name
                request.FILES["profile_picture"].name = f_name

                form = SuntingProfilForm(request.POST, request.FILES, instance=current_user)
                form.save()

                remove_image_exifdata(f_path)
            else:
                form.save()
            return HttpResponseRedirect("/profil-admin/")
        else:
            context = self.get_context_data(**kwargs)
            context["form"] = form
            return self.render_to_response(context)


class ReqMateriView(TemplateView):
    template_name = "req_materi.html"

    def dispatch(self, request, *args, **kwargs):
        if request.user.is_authenticated == False:
            return HttpResponseRedirect("/login/")
        return super(ReqMateriView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(ReqMateriView, self).get_context_data(**kwargs)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        return self.render_to_response(context)

    def post(self, request, *args, **kwargs):
        title = request.POST.get("title", None)
        if title is None:
            return JsonResponse({"success": False, "msg": "Missing parameter"})
        ReqMaterial(title=title).save()
        return JsonResponse({"success": True, "msg": "Permintaan materi berhasil dikirimkan"})


class SuksesLoginKontributorView(TemplateView):
    template_name = "sukses_kontri.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_contributor:
            raise PermissionDenied(request)
        return super(SuksesLoginKontributorView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(SuksesLoginKontributorView, self).get_context_data(**kwargs)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)

        current_user = self.request.user
        context["user"] = current_user

        return self.render_to_response(context)


class SuksesLoginAdminView(TemplateView):
    template_name = "sukses_admin.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_admin:
            raise PermissionDenied(request)
        return super(SuksesLoginAdminView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(SuksesLoginAdminView, self).get_context_data(**kwargs)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)

        current_user = self.request.user
        context["user"] = current_user

        return self.render_to_response(context)


class PostsView(TemplateView):

    template_name = "user_uploaded_posts.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_authenticated:
            raise PermissionDenied(request)
        return super(PostsView, self).dispatch(request, *args, **kwargs)

    def get(self, request, *args, **kwargs):
        context = super().get_context_data(**kwargs)
        user = self.request.user

        posts = Materi.objects.filter(uploader=user).order_by("-date_created")
        posts_data = {post.id: {"data": post, "comments": []} for post in posts}

        comments = Comment.objects.filter(materi__id__in=posts_data.keys()).order_by("-timestamp")

        for comment in comments:
            posts_data[comment.materi.id]["comments"].append(comment)

        context["user"] = user
        context["posts"] = posts_data

        return self.render_to_response(context=context)


class RevisiMateriView(TemplateView):
    template_name = "revisi.html"

    def dispatch(self, request, *args, **kwargs):
        if not request.user.is_contributor:
            raise PermissionDenied(request)
        return super(RevisiMateriView, self).dispatch(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        context = super(RevisiMateriView, self).get_context_data(**kwargs)
        current_materi = get_object_or_404(Materi, pk=kwargs["pk"])
        context["materi"] = current_materi
        context["revisi_form"] = UploadMateriForm(instance=current_materi)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        return self.render_to_response(context)

    def post(self, request, *args, **kwargs):
        if request.user.is_authenticated == False:
            raise PermissionDenied(request)

        current_materi = get_object_or_404(Materi, pk=kwargs["pk"])
        form = UploadMateriForm(request.POST, request.FILES, instance=current_materi)
        if form.is_valid():
            materi = form.save(commit=False)
            materi.uploader = request.user
            materi.status = "REVISION"
            materi.save()
            kateg = form.cleaned_data["categories"]
            for i in kateg:
                materi.categories.add(i)
            materi.save()
            return HttpResponseRedirect("/dashboard/")
        else:
            context = self.get_context_data(**kwargs)
            context["form_revisi"] = form
            return self.render_to_response(context)


def pages(request):
    context = {}
    # All resource paths end in .html.
    # Pick out the html file name from the url. And load that template.
    try:

        load_template = request.path.split("/")[-1]
        template = loader.get_template(load_template)
        return HttpResponse(template.render(context, request))

    except Exception as e:

        template = loader.get_template("error-404.html")
        return HttpResponse(template.render(context, request))


class DownloadHistoryView(TemplateView):
    template_name = "download_history.html"

    def get_context_data(self, **kwargs):
        context = super(DownloadHistoryView, self).get_context_data(**kwargs)
        return context

    def get(self, request, *args, **kwargs):
        context = self.get_context_data(**kwargs)
        if request.user.is_authenticated:
            current_user = self.request.user
            riwayat_list = current_user.riwayat_unduh.all().order_by("-timestamp")
            context["riwayat_list"] = riwayat_list
            context["user_name"] = current_user.name
        else:
            has_downloaded_materi = "downloaded_materi" in request.session
            downloaded_materi = request.session["downloaded_materi"] if has_downloaded_materi else []
            riwayat_list = DownloadStatistics.objects.filter(pk__in=downloaded_materi).order_by("-timestamp")
            context["riwayat_list"] = riwayat_list
            context["user_name"] = "Guest"
        return self.render_to_response(context)


def upload_to_gdrive(file_path, title):
    gauth = GoogleAuth()
    gauth.LocalWebserverAuth()

    drive = GoogleDrive(gauth)
    file1 = drive.CreateFile()
    file1.SetContentFile(file_path)
    file1["title"] = title
    print("title: %s, mimeType: %s" % (file1["title"], file1["mimeType"]))
    file1.Upload()


def save_to_gdrive(request, pk):
    materi = get_object_or_404(Materi, pk=pk)
    path = materi.content.path
    file_path = os.path.join(settings.MEDIA_ROOT, path)
    if os.path.exists(file_path):
        with open(file_path, "rb") as fh:
            upload_to_gdrive(file_path, materi.title)
    else:
        raise Http404("File tidak dapat ditemukan.")

    return HttpResponseRedirect(reverse("detail-materi", kwargs={"pk": pk}))
    
# class PasswordChangeView(PasswordChangeView):
    
#     from_class = PasswordChangeForm
#     success_url = reverse_lazy('password_success')

# def password_success(request):
#     return render(request, 'password_success.html', {})