606 lines
22 KiB
Python
606 lines
22 KiB
Python
from django.shortcuts import get_object_or_404, redirect, render
|
|
from accounts import resource_action
|
|
from goodtimes.services import FacebookAPI, FacebookPoster, InstagramAPI, InstagramPoster, TwitterAPI, TwitterPoster
|
|
from goodtimes.utils import JsonResponseUtil
|
|
from manage_events.api.serializers import VenueSerializer, VenueShortSerializer
|
|
from manage_events.forms import (
|
|
EventMasterForm,
|
|
EventCategoryForm,
|
|
EventForm,
|
|
VenueForm,
|
|
)
|
|
from django.core.paginator import Paginator
|
|
from .models import EventImage, EventMaster, Event, EventCategory, EventPrincipalInteraction, Venue
|
|
from django.views import generic
|
|
from django.contrib.auth.mixins import LoginRequiredMixin
|
|
from django.urls import reverse_lazy
|
|
from django.contrib import messages
|
|
from goodtimes import constants
|
|
from django.contrib.auth import get_user_model
|
|
|
|
# Create your views here.
|
|
|
|
|
|
class EventCategoryCreateOrUpdateView(LoginRequiredMixin, generic.View):
|
|
# Set the page_name and resource
|
|
page_name = resource_action.RESOURCE_MANAGE_EVENTS
|
|
resource = resource_action.RESOURCE_MANAGE_EVENTS
|
|
|
|
# Initialize the action as ACTION_CREATE (can change based on logic)
|
|
action = resource_action.ACTION_CREATE # Default action
|
|
|
|
template_name = "manage_events/event_category_add.html"
|
|
model = EventCategory
|
|
form_class = EventCategoryForm
|
|
success_url = reverse_lazy("manage_events:event_category_list")
|
|
error_message = "An error occurred while saving the data."
|
|
|
|
# Determine the success message dynamically based on whether it's an update or create
|
|
def get_success_message(self):
|
|
self.success_message = (
|
|
constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
|
|
)
|
|
return self.success_message
|
|
|
|
# Get the object (if exists) based on URL parameter 'pk'
|
|
def get_object(self):
|
|
pk = self.kwargs.get("pk")
|
|
return get_object_or_404(self.model, pk=pk) if pk else None
|
|
|
|
# Add page_name and operation to the context
|
|
def get_context_data(self, **kwargs):
|
|
context = {
|
|
"page_name": self.page_name,
|
|
"operation": "Add" if not self.object else "Edit",
|
|
}
|
|
context.update(kwargs) # Include any additional context data passed to the view
|
|
return context
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
|
|
# If an object is found, change action to ACTION_UPDATE
|
|
if self.object is not None:
|
|
self.action = resource_action.ACTION_UPDATE
|
|
|
|
form = self.form_class(instance=self.object)
|
|
context = self.get_context_data(form=form)
|
|
return render(request, self.template_name, context=context)
|
|
|
|
def post(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
|
|
# If an object is found, change action to ACTION_UPDATE
|
|
if self.object is not None:
|
|
self.action = resource_action.ACTION_UPDATE
|
|
|
|
form = self.form_class(request.POST, request.FILES, instance=self.object)
|
|
print("request.FILES: ", request.FILES)
|
|
if not form.is_valid():
|
|
print(form.errors)
|
|
context = self.get_context_data(form=form)
|
|
return render(request, self.template_name, context=context)
|
|
form.save()
|
|
messages.success(self.request, self.get_success_message())
|
|
return redirect(self.success_url)
|
|
|
|
|
|
class EventCategoryView(LoginRequiredMixin, generic.ListView):
|
|
page_name = resource_action.RESOURCE_MANAGE_EVENTS
|
|
resource = resource_action.RESOURCE_MANAGE_EVENTS
|
|
action = resource_action.ACTION_READ
|
|
model = EventCategory
|
|
template_name = "manage_events/event_category_list.html"
|
|
context_object_name = "event_category_obj"
|
|
|
|
def get_queryset(self):
|
|
return super().get_queryset().filter(deleted=False)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context["page_name"] = self.page_name
|
|
return context
|
|
|
|
|
|
class EventCategoryDeleteView(LoginRequiredMixin, generic.View):
|
|
page_name = resource_action.RESOURCE_MANAGE_EVENTS
|
|
resource = resource_action.RESOURCE_MANAGE_EVENTS
|
|
action = resource_action.ACTION_DELETE
|
|
model = EventCategory
|
|
success_url = reverse_lazy("manage_events:event_category_list")
|
|
success_message = constants.RECORD_DELETED
|
|
error_message = constants.RECORD_NOT_FOUND
|
|
|
|
def get(self, request, pk):
|
|
try:
|
|
type_obj = self.model.objects.get(id=pk)
|
|
type_obj.deleted = True
|
|
type_obj.active = False
|
|
type_obj.save()
|
|
messages.success(request, self.success_message)
|
|
except self.model.DoesNotExist:
|
|
messages.success(request, self.error_message)
|
|
|
|
return redirect(self.success_url)
|
|
|
|
|
|
class EventMasterCreateOrUpdateView(LoginRequiredMixin, generic.View):
|
|
# Set the page_name and resource
|
|
page_name = resource_action.RESOURCE_MANAGE_EVENTS
|
|
resource = resource_action.RESOURCE_MANAGE_EVENTS
|
|
|
|
# Initialize the action as ACTION_CREATE (can change based on logic)
|
|
action = resource_action.ACTION_CREATE # Default action
|
|
|
|
template_name = "manage_events/event_master_add.html"
|
|
model = EventMaster
|
|
form_class = EventMasterForm
|
|
success_url = reverse_lazy("manage_events:event_master_list")
|
|
error_message = "An error occurred while saving the data."
|
|
|
|
# Determine the success message dynamically based on whether it's an update or create
|
|
def get_success_message(self):
|
|
self.success_message = (
|
|
constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
|
|
)
|
|
return self.success_message
|
|
|
|
# Get the object (if exists) based on URL parameter 'pk'
|
|
def get_object(self):
|
|
pk = self.kwargs.get("pk")
|
|
return get_object_or_404(self.model, pk=pk) if pk else None
|
|
|
|
# Add page_name and operation to the context
|
|
def get_context_data(self, **kwargs):
|
|
context = {
|
|
"page_name": self.page_name,
|
|
"operation": "Add" if not self.object else "Edit",
|
|
}
|
|
context.update(kwargs) # Include any additional context data passed to the view
|
|
return context
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
|
|
# If an object is found, change action to ACTION_UPDATE
|
|
if self.object is not None:
|
|
self.action = resource_action.ACTION_UPDATE
|
|
|
|
form = self.form_class(instance=self.object)
|
|
context = self.get_context_data(form=form)
|
|
return render(request, self.template_name, context=context)
|
|
|
|
def post(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
|
|
# If an object is found, change action to ACTION_UPDATE
|
|
if self.object is not None:
|
|
self.action = resource_action.ACTION_UPDATE
|
|
|
|
form = self.form_class(request.POST, request.FILES, instance=self.object)
|
|
if not form.is_valid():
|
|
print(form.errors)
|
|
context = self.get_context_data(form=form)
|
|
return render(request, self.template_name, context=context)
|
|
form.save()
|
|
messages.success(self.request, self.get_success_message())
|
|
return redirect(self.success_url)
|
|
|
|
|
|
class EventMasterView(LoginRequiredMixin, generic.ListView):
|
|
page_name = resource_action.RESOURCE_MANAGE_EVENTS
|
|
resource = resource_action.RESOURCE_MANAGE_EVENTS
|
|
action = resource_action.ACTION_READ
|
|
model = EventMaster
|
|
template_name = "manage_events/event_master_list.html"
|
|
context_object_name = "event_master_obj"
|
|
|
|
def get_queryset(self):
|
|
return super().get_queryset().filter(deleted=False)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context["page_name"] = self.page_name
|
|
return context
|
|
|
|
|
|
class EventMasterDeleteView(LoginRequiredMixin, generic.View):
|
|
page_name = resource_action.RESOURCE_MANAGE_EVENTS
|
|
resource = resource_action.RESOURCE_MANAGE_EVENTS
|
|
action = resource_action.ACTION_DELETE
|
|
model = EventMaster
|
|
success_url = reverse_lazy("manage_events:EventMaster_list")
|
|
success_message = constants.RECORD_DELETED
|
|
error_message = constants.RECORD_NOT_FOUND
|
|
|
|
def get(self, request, pk):
|
|
try:
|
|
type_obj = self.model.objects.get(id=pk)
|
|
type_obj.deleted = True
|
|
type_obj.active = False
|
|
type_obj.save()
|
|
messages.success(request, self.success_message)
|
|
except self.model.DoesNotExist:
|
|
messages.success(request, self.error_message)
|
|
|
|
return redirect(self.success_url)
|
|
|
|
from django.core.files.storage import default_storage
|
|
class EventCreateOrUpdateView(LoginRequiredMixin, generic.View):
|
|
# Set the page_name and resource
|
|
page_name = resource_action.RESOURCE_MANAGE_EVENTS
|
|
resource = resource_action.RESOURCE_MANAGE_EVENTS
|
|
|
|
# Initialize the action as ACTION_CREATE (can change based on logic)
|
|
action = resource_action.ACTION_CREATE # Default action
|
|
|
|
template_name = "manage_events/event_add.html"
|
|
model = Event
|
|
form_class = EventForm
|
|
success_url = reverse_lazy("manage_events:event_list")
|
|
error_message = "An error occurred while saving the data."
|
|
|
|
# Determine the success message dynamically based on whether it's an update or create
|
|
def get_success_message(self):
|
|
self.success_message = (
|
|
constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
|
|
)
|
|
return self.success_message
|
|
|
|
# Get the object (if exists) based on URL parameter 'pk'
|
|
def get_object(self):
|
|
pk = self.kwargs.get("pk")
|
|
return get_object_or_404(self.model, pk=pk) if pk else None
|
|
|
|
# Add page_name and operation to the context
|
|
def get_context_data(self, **kwargs):
|
|
context = {
|
|
"page_name": self.page_name,
|
|
"operation": "Add" if not self.object else "Edit",
|
|
}
|
|
context.update(kwargs) # Include any additional context data passed to the view
|
|
return context
|
|
|
|
def get_event_images(self):
|
|
return [image.image.url for image in EventImage.objects.filter(event=self.object)]
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
|
|
# If an object is found, change action to ACTION_UPDATE
|
|
if self.object is not None:
|
|
self.action = resource_action.ACTION_UPDATE
|
|
|
|
form = self.form_class(instance=self.object)
|
|
|
|
context = self.get_context_data(form=form, event_images_urls=self.get_event_images())
|
|
return render(request, self.template_name, context=context)
|
|
|
|
def post(self, request, *args, **kwargs):
|
|
print(request.POST)
|
|
print(request.FILES)
|
|
self.object = self.get_object()
|
|
|
|
# If an object is found, change action to ACTION_UPDATE
|
|
if self.object is not None:
|
|
self.action = resource_action.ACTION_UPDATE
|
|
|
|
principal_id = request.POST.get('principal')
|
|
|
|
form = self.form_class(request.POST, request.FILES, instance=self.object, principal_id=principal_id)
|
|
if not form.is_valid():
|
|
print(f"form error is {form.errors}")
|
|
context = self.get_context_data(form=form, event_images_urls=self.get_event_images())
|
|
return render(request, self.template_name, context=context)
|
|
instance = form.save()
|
|
instance.created_by = form.cleaned_data.get("principal")
|
|
instance.save()
|
|
|
|
# Delete old images from storage
|
|
old_images = EventImage.objects.filter(event=instance)
|
|
for old_image in old_images:
|
|
if default_storage.exists(old_image.image.name):
|
|
default_storage.delete(old_image.image.name)
|
|
|
|
# Delete old images from database
|
|
old_images.delete()
|
|
|
|
event_images = request.FILES.getlist("event_images")
|
|
event_image_objects = [EventImage(event=instance, image=image) for image in event_images]
|
|
|
|
EventImage.objects.bulk_create(event_image_objects)
|
|
|
|
messages.success(self.request, self.get_success_message())
|
|
|
|
return redirect(self.success_url)
|
|
|
|
|
|
class EventView(LoginRequiredMixin, generic.ListView):
|
|
page_name = resource_action.RESOURCE_MANAGE_EVENTS
|
|
resource = resource_action.RESOURCE_MANAGE_EVENTS
|
|
action = resource_action.ACTION_READ
|
|
model = Event
|
|
template_name = "manage_events/event_list.html"
|
|
context_object_name = "event_obj"
|
|
# paginate_by = 10
|
|
|
|
def get_queryset(self):
|
|
return super().get_queryset().all()
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context["page_name"] = self.page_name
|
|
return context
|
|
|
|
# # Paginate the queryset
|
|
# queryset = self.get_queryset()
|
|
# page_obj = Paginator(queryset, self.paginate_by)
|
|
# page_number = self.request.GET.get(
|
|
# "page"
|
|
# ) # Get current page from URL parameter
|
|
# page_obj = page_obj.get_page(page_number)
|
|
|
|
# context.update(
|
|
# {
|
|
# "events": page_obj.object_list,
|
|
# "paginator": page_obj,
|
|
# "is_paginated": page_obj.has_other_pages(), # Check if there are more pages
|
|
# }
|
|
# )
|
|
|
|
# return context
|
|
|
|
|
|
class EventDetailView(generic.DetailView):
|
|
page_name = resource_action.RESOURCE_MANAGE_EVENTS
|
|
resource = resource_action.RESOURCE_MANAGE_EVENTS
|
|
action = resource_action.ACTION_READ
|
|
model = Event
|
|
template_name = "manage_events/event_details.html"
|
|
context_object_name = "event"
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context["page_name"] = self.page_name
|
|
event_id = self.object.id # Get the current event's ID
|
|
|
|
# Separate count for interested and going
|
|
interested_count = EventPrincipalInteraction.objects.filter(
|
|
event_id=event_id, status="interested"
|
|
).count()
|
|
going_count = EventPrincipalInteraction.objects.filter(
|
|
event_id=event_id, status="going"
|
|
).count()
|
|
|
|
context["interested_count"] = interested_count
|
|
context["going_count"] = going_count
|
|
|
|
# Reviews for the event
|
|
context["reviews"] = self.object.reviews.all()
|
|
|
|
# Images of the event
|
|
context["images"] = self.object.event_images.all()
|
|
|
|
return context
|
|
|
|
|
|
class EventDeleteView(LoginRequiredMixin, generic.View):
|
|
page_name = resource_action.RESOURCE_MANAGE_EVENTS
|
|
resource = resource_action.RESOURCE_MANAGE_EVENTS
|
|
action = resource_action.ACTION_DELETE
|
|
model = Event
|
|
success_url = reverse_lazy("manage_events:event_list")
|
|
success_message = constants.RECORD_DELETED
|
|
error_message = constants.RECORD_NOT_FOUND
|
|
|
|
def get(self, request, pk):
|
|
try:
|
|
type_obj = self.model.objects.get(id=pk)
|
|
type_obj.deleted = True
|
|
type_obj.active = False
|
|
type_obj.save()
|
|
messages.success(request, self.success_message)
|
|
except self.model.DoesNotExist:
|
|
messages.success(request, self.error_message)
|
|
|
|
return redirect(self.success_url)
|
|
|
|
|
|
class VenueCreateOrUpdateView(LoginRequiredMixin, generic.View):
|
|
# Set the page_name and resource
|
|
page_name = resource_action.RESOURCE_MANAGE_VENUES
|
|
resource = resource_action.RESOURCE_MANAGE_VENUES
|
|
|
|
# Initialize the action as ACTION_CREATE (can change based on logic)
|
|
action = resource_action.ACTION_CREATE # Default action
|
|
|
|
template_name = "manage_venues/venue_add.html"
|
|
model = Venue
|
|
form_class = VenueForm
|
|
success_url = reverse_lazy("manage_events:venue_list")
|
|
error_message = "An error occurred while saving the data."
|
|
|
|
# Determine the success message dynamically based on whether it's an update or create
|
|
def get_success_message(self):
|
|
self.success_message = (
|
|
constants.RECORD_CREATED if not self.object else constants.RECORD_UPDATED
|
|
)
|
|
return self.success_message
|
|
|
|
# Get the object (if exists) based on URL parameter 'pk'
|
|
def get_object(self):
|
|
pk = self.kwargs.get("pk")
|
|
return get_object_or_404(self.model, pk=pk) if pk else None
|
|
|
|
# Add page_name and operation to the context
|
|
def get_context_data(self, **kwargs):
|
|
context = {
|
|
"page_name": self.page_name,
|
|
"operation": "Add" if not self.object else "Edit",
|
|
}
|
|
context.update(kwargs) # Include any additional context data passed to the view
|
|
return context
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
print(f"self.object is {self.object}")
|
|
|
|
# If an object is found, change action to ACTION_UPDATE
|
|
if self.object is not None:
|
|
self.action = resource_action.ACTION_UPDATE
|
|
|
|
form = self.form_class(instance=self.object)
|
|
context = self.get_context_data(form=form)
|
|
return render(request, self.template_name, context=context)
|
|
|
|
def post(self, request, *args, **kwargs):
|
|
self.object = self.get_object()
|
|
print(f"form data is {request.POST} and self.object is {self.object}")
|
|
|
|
# If an object is found, change action to ACTION_UPDATE
|
|
if self.object is not None:
|
|
self.action = resource_action.ACTION_UPDATE
|
|
|
|
form = self.form_class(request.POST, request.FILES, instance=self.object)
|
|
if not form.is_valid():
|
|
print(form.errors)
|
|
context = self.get_context_data(form=form)
|
|
return render(request, self.template_name, context=context)
|
|
|
|
instance = form.save()
|
|
instance.created_by = form.cleaned_data.get("principal")
|
|
instance.save()
|
|
messages.success(self.request, self.get_success_message())
|
|
return redirect(self.success_url)
|
|
|
|
|
|
class VenueView(LoginRequiredMixin, generic.ListView):
|
|
page_name = resource_action.RESOURCE_MANAGE_VENUES
|
|
resource = resource_action.RESOURCE_MANAGE_VENUES
|
|
action = resource_action.ACTION_READ
|
|
model = Venue
|
|
template_name = "manage_venues/venue_list.html"
|
|
context_object_name = "venue_obj"
|
|
# paginate_by = 10
|
|
|
|
def get_queryset(self):
|
|
return super().get_queryset().filter(deleted=False, active=True)
|
|
|
|
def get_context_data(self, **kwargs):
|
|
context = super().get_context_data(**kwargs)
|
|
context["page_name"] = self.page_name
|
|
return context
|
|
|
|
|
|
class VenueDeleteView(LoginRequiredMixin, generic.View):
|
|
page_name = resource_action.RESOURCE_MANAGE_VENUES
|
|
resource = resource_action.RESOURCE_MANAGE_VENUES
|
|
action = resource_action.ACTION_DELETE
|
|
model = Venue
|
|
success_url = reverse_lazy("manage_events:venue_list")
|
|
success_message = constants.RECORD_DELETED
|
|
error_message = constants.RECORD_NOT_FOUND
|
|
|
|
def get(self, request, pk):
|
|
try:
|
|
type_obj = self.model.objects.get(id=pk)
|
|
type_obj.deleted = True
|
|
type_obj.active = False
|
|
type_obj.save()
|
|
messages.success(request, self.success_message)
|
|
except self.model.DoesNotExist:
|
|
messages.success(request, self.error_message)
|
|
|
|
return redirect(self.success_url)
|
|
|
|
|
|
class CustomerVenueFilterView(LoginRequiredMixin, generic.View):
|
|
model = Venue
|
|
serializer_class = VenueShortSerializer
|
|
|
|
def get(self, request, *args, **kwargs):
|
|
pk = request.GET.get("pk", None)
|
|
if not pk:
|
|
return JsonResponseUtil.error(message="Non transfer user list field is required")
|
|
obj = self.model.objects.filter(principal=pk, active=True)
|
|
if not obj.exists():
|
|
return JsonResponseUtil.error(message="No venue found for the given user.")
|
|
|
|
serializer = self.serializer_class(obj, many=True)
|
|
|
|
return JsonResponseUtil.success(message=constants.SUCCESS, data=serializer.data)
|
|
|
|
|
|
User = get_user_model()
|
|
from .report import generate_event_report, generate_event_report_pdf_three
|
|
from django.http import HttpResponse
|
|
|
|
|
|
class GenerateEventReportView(generic.View):
|
|
|
|
def get(self, request, user_id):
|
|
print("INside GET GenerateEventReportView")
|
|
# Generate the event report
|
|
report_data = generate_event_report(user_id)
|
|
|
|
# Get the user
|
|
user = get_object_or_404(User, id=user_id)
|
|
|
|
# Generate the PDF
|
|
pdf_data, filename = generate_event_report_pdf_three(user, report_data)
|
|
|
|
# Create the HttpResponse object with the PDF data
|
|
response = HttpResponse(pdf_data, content_type="application/pdf")
|
|
response["Content-Disposition"] = f'attachment; filename="{filename}"'
|
|
|
|
return response
|
|
|
|
class SocialMediaPostView(generic.View):
|
|
def get(self, request, *args, **kwargs):
|
|
platform = kwargs.get("platform")
|
|
event_id = kwargs.get("id")
|
|
print(platform, event_id)
|
|
errors = []
|
|
|
|
try:
|
|
event = Event.objects.get(id=event_id)
|
|
except Event.DoesNotExist:
|
|
errors.append("Event does not exist")
|
|
return JsonResponseUtil.error(message=errors, errors=errors)
|
|
|
|
if not event.active:
|
|
errors.append("Event is not active")
|
|
return JsonResponseUtil.error(message=errors, errors=errors)
|
|
|
|
caption = f"{event.title}\nDuration: {event.start_date} to {event.end_date}\nAddress: {event.venue.address}"
|
|
print(f"image url and caption is {caption}")
|
|
if platform in ['instagram', 'facebook', 'twitter', 'all']:
|
|
|
|
if platform in ['twitter', 'all']:
|
|
image_url = event.image.path
|
|
twitter_api = TwitterAPI()
|
|
twitter_poster = TwitterPoster(twitter_api)
|
|
result = twitter_poster.post_image_with_caption(image_url, caption)
|
|
if not result['success']:
|
|
errors.append(result['message'])
|
|
|
|
image_url = request.build_absolute_uri(event.image.url) # fb and insta require complete path with domain
|
|
if platform in ['facebook', 'all']:
|
|
facebook_api = FacebookAPI()
|
|
facebook_poster = FacebookPoster(facebook_api)
|
|
result = facebook_poster.post_photo(image_url, caption)
|
|
if not result["success"]:
|
|
errors.append(result["message"])
|
|
|
|
if platform in ['instagram', 'all']:
|
|
instagram_api = InstagramAPI()
|
|
instagram_poster = InstagramPoster(instagram_api)
|
|
result = instagram_poster.post_image_with_caption(image_url, caption)
|
|
if not result["success"]:
|
|
errors.append(result["message"])
|
|
|
|
if not errors:
|
|
return JsonResponseUtil.success(message='Post Successful')
|
|
|
|
return JsonResponseUtil.error(message=errors, errors=errors)
|