JourneyJoker/partners/views.py

from django.views.generic import CreateView, UpdateView, ListView, DetailView, FormView, View
from django.urls import reverse_lazy
from django.http import HttpResponseRedirect
from django.shortcuts import get_list_or_404, redirect, get_object_or_404
from django.contrib import messages
from django.http.response import JsonResponse
from django.utils.translation import gettext_lazy as _

from .models import PartnerProfile, Establishment, RoomCategory
from .mixins import PartnerProfileRequiredMixin
from .forms import VerificationForm

from auction.models import Inquiry, Offer
from frontend.mixins import InConstructionMixin
from localauth.mixins import LoginRequiredMixin, SuperUserRequiredMixin
from gallery.models import Image

from django_starfield import Stars

import uuid

class PartnerRegistrationView(InConstructionMixin, LoginRequiredMixin, CreateView):
    model = PartnerProfile
    exclude = ["user"]
    template_name = "partners/signup.html"
    fields = ["company", "vat_id", "first_name", "last_name", "street", "city", "zip", "state", "country", "phone"]

    def dispatch(self, request, *args, **kwargs):
        try:
            PartnerProfile.objects.get(user=request.user)
            return HttpResponseRedirect(reverse_lazy("partners:profile"))
        except (PartnerProfile.DoesNotExist, TypeError):
            return super().dispatch(request, *args, **kwargs)

    def form_valid(self, form):
        form.instance.user = self.request.user
        return super().form_valid(form)

    def get_success_url(self):
        messages.success(self.request, _("Profil erfolgreich angelegt!"))
        return reverse_lazy("partners:profile")

    def get_initial(self):
        try:
            client = self.request.user.clientprofile

            return {
                "company": client.company,
                "vat_id": client.vat_id,
                "first_name": client.first_name,
                "last_name": client.last_name,
                "street": client.street,
                "city": client.city,
                "zip": client.zip,
                "state": client.state,
                "country": client.country,
                "phone": client.phone
            }

        except:
            return {
                "country": "AT",
                "phone": "+43"
                }

class PartnerProfileView(InConstructionMixin, PartnerProfileRequiredMixin, UpdateView):
    model = PartnerProfile
    exclude = ["user"]
    template_name = "partners/profile.html"
    fields = ["company", "vat_id", "first_name", "last_name", "street", "city", "zip", "state", "country"]

    def get_success_url(self):
        return reverse_lazy("partners:profile")

    def get_object(self, queryset=None):
        return self.request.user.partnerprofile

class OffersListView(InConstructionMixin, PartnerProfileRequiredMixin, ListView):
    model = Offer
    template_name = "partners/offer_list.html"

    def get_queryset(self):
        return Offer.objects.filter(roomcategory__in=self.request.user.partnerprofile.roomcategory_set.all())

class EstablishmentsListView(InConstructionMixin, PartnerProfileRequiredMixin, ListView):
    model = Establishment
    template_name = "partners/establishment_list.html"

    def get_queryset(self):
        return self.request.user.partnerprofile.establishment_set.all()

class RoomCategoryListView(InConstructionMixin, PartnerProfileRequiredMixin, CreateView, ListView):
    model = RoomCategory
    template_name = "partners/roomcategory_list.html"
    fields = ["name", "average_price"]

    def dispatch(self, request, *args, **kwargs):
        self.establishment = self.get_establishment()

        if not self.establishment:
            messages.warning(request, _("Um bieten zu können, muss zuerst eine Unterkunft im System hinterlegt werden!"))
            return redirect("partners:establishment_register")

        return super().dispatch(request, *args, **kwargs)

    def get_establishment(self):
        establishment = self.kwargs.get("id", None)
        kwargs = {"owner": self.request.user.partnerprofile}

        if establishment:
            kwargs["id"] = establishment
            return get_object_or_404(Establishment, **kwargs)
        else:
            return Establishment.objects.filter(**kwargs).first()

    def get_queryset(self):
        establishment = self.establishment
        return RoomCategory.objects.filter(establishment=establishment)

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

    def form_valid(self, form):
        form.instance.establishment = self.establishment
        return super().form_valid(form)

    def get_success_url(self):
        return reverse_lazy("partners:roomcategories", args=[self.establishment.id])

class EstablishmentRequestView(InConstructionMixin, PartnerProfileRequiredMixin, CreateView):
    model = Establishment
    template_name = "partners/establishment_register.html"
    fields = ["name", "stars", "superior", "street", "city", "zip", "state", "country", "image"]

    def form_valid(self, form):
        form.instance.owner = self.request.user.partnerprofile
        retval = super().form_valid(form)

        RoomCategory.objects.create(name=_("Einzelzimmer"), average_price=100, active=False, establishment=form.instance) # TODO: Move somewhere better
        RoomCategory.objects.create(name=_("Doppelzimmer"), average_price=100, active=False, establishment=form.instance)

        return retval

    def get_success_url(self):
        return reverse_lazy("partners:establishments")

    def get_form(self, form_class=None):
        form = super().get_form(form_class)
        form.fields['stars'].widget = Stars()
        return form

class PartnerDashboardView(InConstructionMixin, PartnerProfileRequiredMixin, DetailView):
    model = PartnerProfile
    template_name = "partners/dashboard.html"

    def get_object(self):
        return self.request.user.partnerprofile

class EstablishmentVerificationView(SuperUserRequiredMixin, FormView):
    form_class = VerificationForm
    template_name = "partners/establishment_verify.html"

    def form_valid(self, form):
        eid = form.cleaned_data["establishment"]
        eobj = Establishment.objects.filter(id=eid)
        eobj.update(verified=True)

        messages.success(self.request, _("Unterkunft %s bestätigt!") % eobj[0].name)

        return HttpResponseRedirect(reverse_lazy("partners:establishment_verify"))

class EstablishmentGalleryManagementView(PartnerProfileRequiredMixin, CreateView, ListView):
    model = Image
    template_name = "partners/establishment_gallery_manage.html"
    fields = ["image", "title", "comment"]

    def dispatch(self, request, *args, **kwargs):
        self.establishment = self.get_establishment()
        self.object_list = self.get_queryset()

        if not self.establishment:
            return redirect("partners:establishment_register")

        return super().dispatch(request, *args, **kwargs)

    def get_establishment(self):
        establishment = self.kwargs.get("id", None)
        kwargs = {"owner": self.request.user.partnerprofile}

        if establishment:
            kwargs["id"] = establishment
            return get_object_or_404(Establishment, **kwargs)
        else:
            return Establishment.objects.filter(**kwargs).first()

    def get_queryset(self):
        establishment = self.establishment
        return establishment.image_set.all()

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

    def form_valid(self, form):
        form.instance.content_object = self.establishment

        for filename, file in self.request.FILES.items():
            name = self.request.FILES[filename].name

        form.instance.upload_path = f"userfiles/{self.request.user.id}/{uuid.uuid4()}/{name}"
        return super().form_valid(form)

    def get_success_url(self):
        return reverse_lazy("partners:establishment_gallery", args=[self.establishment.id])

class RoomCategoryGalleryManagementView(PartnerProfileRequiredMixin, CreateView, ListView):
    model = Image
    template_name = "partners/roomcategory_gallery_manage.html"
    fields = ["image", "title", "comment"]

    def dispatch(self, request, *args, **kwargs):
        self.roomcategory = self.get_roomcategory()
        self.object_list = self.get_queryset()

        if not self.roomcategory:
            return redirect("partners:establishment_register")

        return super().dispatch(request, *args, **kwargs)

    def get_roomcategory(self):
        roomcategory = self.kwargs.get("cid", None)
        kwargs = {"establishment_owner": self.request.user}

        if roomcategory:
            kwargs["id"] = roomcategory
            return get_object_or_404(RoomCategory, **kwargs)
        else:
            return RoomCategory.objects.filter(**kwargs).first()

    def get_queryset(self):
        roomcategory = self.roomcategory
        return roomcategory.image_set.all()

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

    def form_valid(self, form):
        form.instance.content_object = self.roomcategory

        for filename, file in self.request.FILES.items():
            name = self.request.FILES[filename].name

        form.instance.upload_path = f"userfiles/{self.request.user.id}/{uuid.uuid4()}/{name}"
        return super().form_valid(form)

    def get_success_url(self):
        return reverse_lazy("partners:roomcategory_gallery", args=[self.roomcategory.establishment.id, self.roomcategory.id])

class RoomCategoryCalendarAPIView(View):
    def get(self, request, *args, **kwargs):
        rc = get_object_or_404(RoomCategory, id=kwargs["room"], establishment__id=kwargs["establishment"], establishment__owner=request.user)
        
        events = []



        return JsonResponse(events, safe=False)

class RoomCategoryDefaultPricingView(FormView):
    form_class = None
    template_name = "partners/default_pricing.html"

    def form_valid(self, form):
        pass