def post(self, request, public_id=None):
data = TicketCreateSerializer(data=request.data)
if data.is_valid():
payment = Payment.objects.filter(
public_id=data.validated_data.get("payment_id")).first()
if payment:
if payment.user != request.user:
raise UserDoesNotHavePayment()
if not data.validated_data.get("is_ok"):
payment.delete()
payment.event.available_places = payment.event.available_places + payment.quantity
payment.event.save()
return response()
event = payment.event
if payment.is_expired:
raise PaymentExpired()
payment.end_time = get_current_time()
payment.is_expired = True
payment.refund_id = data.validated_data.get("refund_id")
payment.save()
else:
raise PaymentNotFound
result = []
email_result = []
for i in range(0, payment.quantity):
ticket = Ticket.objects.create(user=request.user,
event=event,
is_vip=payment.is_vip)
result.append(ticket.public_id)
email_result.append(ticket)
send_celery_email('Bought Tickets', request.user.email,
settings.TICKET_TEMPLATE, email_result)
return response(data=result)
raise ValidationError(
error_list=error_many_list_serializer(data.errors))
def custom_exception_handler(exc, context):
# Call REST framework's default exception handler first,
# to get the standard error response.
resp = None
if isinstance(exc, AuthException) or isinstance(exc, UserCrudException) or isinstance(exc, ValidationErrorBase) or \
isinstance(exc, EventCrudException) or isinstance(exc, BuyTicketException) or \
isinstance(exc, SubscribeException) or isinstance(exc, RefundException):
return response(errors=[exc.serialize()], success=False)
elif isinstance(exc, APIException):
resp = response(errors=[{
"error_code": 1,
"error_message": exc.default_detail,
"fields": [],
"translation_key": exc.default_code
}],
status=exc.status_code,
success=False)
# todo log exception
else:
print(exc)
exc = UnExpectedError()
resp = response(errors=[{
"error_code": 1,
"error_message": exc.default_detail,
"fields": [],
"translation_key": exc.default_code
}],
status=exc.status_code,
success=False)
# Now add the HTTP status code to the response.
if resp is not None:
resp['status_code'] = exc.status_code
return resp
def post(self, request, public_id):
event = Event.objects.filter(public_id=public_id).first()
if not event:
raise EventNotFound
if event.ticket_fee == 0:
data = FreeTicketCreateSerializer(data=request.data)
if data.is_valid():
if Ticket.objects.filter(user=request.user, event=event).count(
) + data.validated_data.get("quant") > TICKET_AMOUNT:
raise UserCanBuyAtMostFreeTickets(TICKET_AMOUNT)
result = []
email_result = []
for i in range(0, data.validated_data.get("quant")):
ticket = Ticket.objects.create(
user=request.user,
event=event,
is_vip=data.validated_data.get("is_vip"))
result.append(ticket.public_id)
email_result.append(ticket)
send_celery_email('Bought Tickets', request.user.email,
settings.TICKET_TEMPLATE, email_result)
return response(data=result)
raise ValidationError(
error_list=error_many_list_serializer(data.errors))
raise UserPermission
def post(self, request):
data = SubscriptionSerializer(data=request.data)
if data.is_valid():
data.create(data.validated_data)
return response()
raise ValidationError(
error_list=error_many_list_serializer(data.errors))
def post(self, request):
ResetPasswordSerializer(
data=request.data,
session=Session.objects.get(
token=request.session_token)).validate_passwords(request.user)
Session.expire_all_sessions(request.user)
return response()
def post(self, request, public_id=None):
data = EventCreateSerializer(data=request.data)
if data.is_valid():
if data.validated_data.get('ticket_fee') == 0:
try:
charge = stripe.Charge.create(
amount=settings.FREE_EVENT_CHARGE,
currency="amd",
source=request.user.stripe_id)
except Exception as e:
raise StripeError()
event = data.create(data.validated_data)
event.host = request.user
event.available_places = event.ticket_amount
event.save()
if event.ticket_fee == 0:
Payment.objects.create(end_time=get_current_time(),
amount=settings.FREE_EVENT_CHARGE,
event=event,
user=request.user,
reason=1,
refund_id=charge['id'])
return response(data=event.serialize(extra_info=True))
# errors.update(data.errors)
raise ValidationError(
error_list=error_many_list_serializer(data.errors))
def get(self, request):
user = request.user
all_categories = user.categories.all()
if all_categories is not None:
return response(
data={"categories": [i.serialize() for i in all_categories]})
raise UserHasNoCategory()
def delete(self, request, public_id):
data = CategoryUserSerializer(data=request.data, event=request.event)
if data.is_valid():
data.remove(request.event, data.validated_data)
return response()
raise ValidationError(
error_list=error_many_list_serializer(data.errors))
def patch(self, request, public_id):
event = request.event
if not request.data:
raise AddressDataNotValid()
data = AddressSerializer(data=request.data)
if data.is_valid():
address = event.address
if address:
address_hash = data.get_hash(data.validated_data)
found_address = Address.objects.filter(
hash=address_hash).first()
# todo find better solution of finding all relationships
if not (CustomUser.objects.filter(address=address)
and Event.objects.filter(address=address).count() > 1):
data.update(address, data.validated_data)
elif not found_address:
address = data.create(data.validated_data)
else:
address = found_address
event.address = address
event.save()
return response()
raise EventHasNoAddress()
raise ValidationError(
error_list=error_many_list_serializer(data.errors))
def delete(self, request):
user = request.user
if user.is_company:
events = Event.objects.filter(host=user,
is_responsible=False,
end_date__lt=get_current_time())
if events and Ticket.objects.filter(event__in=events):
raise CannotDeleteUserHavingEvents()
events = Event.objects.filter(host=user,
is_responsible=True,
all_user_payments_refunded=False)
if events and Ticket.objects.filter(event__in=events):
for i in events:
try:
refund_all_event_users(i)
except NoPaymentIsMade as e:
pass
except StripeError() as e:
raise e
i.all_user_payments_refunded = True
events = Event.objects.filter(host=user)
for i in events:
i.delete()
Session.expire_all_sessions(user=request.user)
user.is_active = False
user.save()
return response()
def patch(self, request, public_id):
event = request.event
data = EventCompanyUser(data=request.data)
if data.is_valid():
data.update(event, data.validated_data)
return response()
raise ValidationError(
error_list=error_many_list_serializer(data.errors))
def get(self, request, public_id=None):
page = request.GET.get('page', 1)
user = request.user
if public_id is None:
events_data = Event.objects.filter(host=user)
if not events_data:
if request.user.is_company:
events_data = Event.objects.filter(users=user)
else:
events_data = Event.objects.filter(id__in=Subquery(
Ticket.objects.filter(user=user).values('event__id')))
if not events_data:
raise UserHasNoEvent()
events_data = EventFilter(
request.GET, events_data.order_by('-creation_date')).qs
if events_data is not None:
paginator = Paginator(events_data, settings.PAGE_SIZE)
# if int(page) > events_data.num_pages or int(page) < 1:
# raise NotFound
try:
events_data = paginator.page(page)
except PageNotAnInteger:
events_data = paginator.page(1)
page = 1
except EmptyPage:
events_data = paginator.page(paginator.num_pages)
page = paginator.num_pages
return response(
data={
"events":
[i.serialize(extra_info=True) for i in events_data],
"current_page":
page,
"last_page":
paginator.num_pages,
"has_next":
events_data.has_next(),
"has_previous":
events_data.has_previous()
})
else:
event = Event.objects.filter(public_id=public_id).first()
if not event:
raise EventNotFound
return response(data=event.serialize(extra_info=True))
def post(self, request):
# todo check validation errors
user = request.user
data = CategoryUserSerializer(data=request.data, user=user)
if data.is_valid():
data.update(user, data.validated_data)
return response()
raise ValidationError(
error_list=error_many_list_serializer(data.errors))
def get(self, request):
page = request.GET.get('page', 1)
events_data = EventFilter(
request.GET,
queryset=Event.objects.all().order_by('-creation_date')).qs
# filter_data = {"categories": request.GET.get('categories').split(',')
# if isinstance(request.GET.get('categories', ""), str) and request.GET.get('categories') else [],
# "states": request.GET.get('states').split(',')
# if isinstance(request.GET.get('states', ""), str) and request.GET.get('states') else [],
# "cities": request.GET.get('cities', "").split(',')
# if isinstance(request.GET.get('cities', ""), str) and request.GET.get('cities') else [],
# "start_date": string_to_int(request.GET.get('start_date', "2")),
# "ticket_fee": string_to_int(request.GET.get('ticket_fee', "2")),
# "free": string_to_bool(request.GET.get('free', "False")),
# "is_responsible": string_to_bool(request.GET.get('is_responsible', "True"))}
# data = EventFilterSerializer(data=filter_data)
# if data.is_valid():
# events_data = Event.objects.all()
# if isinstance(data.validated_data['is_responsible'], bool):
# events_data = events_data.filter(Q(is_responsible=data.validated_data['is_responsible']))
# if data.validated_data["free"]:
# events_data = events_data.filter(Q(ticket_fee=0))
# elif data.validated_data["free"] == False:
# free_query = events_data.filter(Q(ticket_fee__gt=0))
# if data.validated_data["categories"]:
# events_data = events_data.filter(Q(categories__name__in=data.validated_data["categories"]))
# if data.validated_data["states"]:
# events_data = events_data.filter(Q(address__state__in=data.validated_data["states"]))
# if data.validated_data["cities"]:
# events_data = events_data.filter(Q(address__city__in=data.validated_data["cities"]))
# events_data = events_data.filter(Q(end_date__gte=get_current_time())).distinct()
# if data.validated_data["start_date"] != 2:
# events_data = events_data.order_by("start_date") if \
# data.validated_data["start_date"] == 0 else events_data.order_by("-start_date")
# if data.validated_data["ticket_fee"] != 2:
# events_data = events_data.order_by("ticket_fee") if \
# data.validated_data["ticket_fee"] == 0 else events_data.order_by("-ticket_fee")
paginator = Paginator(events_data, settings.PAGE_SIZE)
# if int(page) > events_data.num_pages or int(page) < 1:
# raise NotFound
try:
events_data = paginator.page(page)
except PageNotAnInteger:
events_data = paginator.page(1)
page = 1
except EmptyPage:
events_data = paginator.page(paginator.num_pages)
page = paginator.num_pages
return response(
data={
"events": [i.serialize(extra_info=True) for i in events_data],
"current_page": page,
"last_page": paginator.num_pages,
"has_next": events_data.has_next(),
"has_previous": events_data.has_previous()
})
def delete(self, request):
user = request.user
address = user.address
if address:
user.address = None
user.save()
if not (CustomUser.objects.filter(address=address)
and Event.objects.filter(address=address)):
address.delete()
return response()
raise UserHasNoAddress()
def post(self, request):
if not request.data.get("is_company"):
data = UserRegistrationSerializer(data=request.data)
else:
data = CompanyRegistrationSerializer(data=request.data)
if data.is_valid():
user = data.create(validated_data=data.validated_data)
if user is not None:
return response(data=user.serialize(extra_info=True))
raise ValidationError(
error_list=error_many_list_serializer(data.errors))
def post(self, request):
data = PaymentSerializer(data=request.data)
if data.is_valid():
event = Event.objects.filter(
public_id=data.validated_data.get("public_id")).first()
if not event:
raise EventNotFound
if event.ticket_fee == 0:
raise UserPermission
if event.available_places < data.validated_data.get('quant'):
raise NoAvailablePlaces()
if event.end_date < get_current_time():
raise CannotPayForPassedEvent()
event.available_places = event.available_places - data.validated_data.get(
'quant')
event.save()
amount = data.validated_data.get('quant')*event.ticket_fee if not data.validated_data.get('is_vip') \
else data.validated_data.get('quant')*event.vip_ticket_fee
if not event.is_responsible:
try:
payment_intent = stripe.PaymentIntent.create(
payment_method_types=['card'],
amount=amount * 100,
currency='amd',
application_fee_amount=100 * amount *
settings.CHARGE_PERCENTAGE / 100,
stripe_account=event.host.stripe_id,
receipt_email=settings.EMAIL_HOST_USER)
except Exception as e:
raise StripeError()
else:
try:
payment_intent = stripe.PaymentIntent.create(
payment_method_types=['card'],
amount=amount * 100,
currency='amd',
receipt_email=settings.EMAIL_HOST_USER)
except Exception as e:
raise StripeError()
payment = Payment.objects.create(
amount=amount,
quantity=data.validated_data.get('quant'),
is_vip=data.validated_data.get('is_vip'),
user=request.user,
event=event)
return response(
data={
"client_secret": payment_intent.client_secret,
"payment_id": payment.public_id,
"public_id": data.validated_data.get("public_id")
})
raise ValidationError(
error_list=error_many_list_serializer(data.errors))
def patch(self, request, public_id=None):
if public_id:
event = Event.objects.filter(public_id=public_id).first()
if event:
data = EventUpdateSerializer(data=request.data, event=event)
if data.is_valid():
event = data.update(event, data.validated_data)
return response(data=event.serialize())
raise ValidationError(
error_list=error_many_list_serializer(data.errors))
raise EventNotFound
raise NotFound
def patch(self, request):
user = request.user
request_data = request.data
if request_data:
data = UserUpdateSerializer(data=request_data)
if data.is_valid():
user = data.update(instance=user,
validated_data=data.validated_data)
if user is not None:
return response()
raise ValidationError(
error_list=error_many_list_serializer(data.errors))
raise UserDataNotValid()
def post(self, request):
user = request.user
data = AddressSerializer(data=request.data)
if data.is_valid():
hash = data.get_hash(data.validated_data)
address = Address.objects.filter(hash=hash)
if not address:
address = data.create(data.validated_data)
user.address = address
user.save()
return response()
raise UserHasAddress()
raise ValidationError(
error_list=error_many_list_serializer(data.errors))
def get(self, request, public_id=None):
page = request.GET.get('page', 1)
user = request.user
if public_id is None:
tickets = Ticket.objects.filter(user=user)
if tickets is not None:
tickets = TicketFilter(request.GET, queryset=tickets).qs
paginator = Paginator(tickets, settings.TICKET_PAGE_SIZE)
# if int(page) > events_data.num_pages or int(page) < 1:
# raise NotFound
try:
tickets = paginator.page(page)
except PageNotAnInteger:
tickets = paginator.page(1)
page = 1
except EmptyPage:
tickets = paginator.page(paginator.num_pages)
page = paginator.num_pages
return response(
data={
"tickets":
[i.serialize(extra_info=False) for i in tickets],
"current_page": page,
"last_page": paginator.num_pages,
"has_next": tickets.has_next(),
"has_previous": tickets.has_previous()
})
raise UserHasNoTicket()
else:
if public_id:
ticket = Ticket.objects.filter(public_id=public_id).first()
if not ticket:
raise TicketNotFound
if not ticket.user == request.user:
raise UserPermission
return response(data=ticket.serialize(extra_info=True))
return response()
def put(self, request, public_id=None):
data = TicketUpdateSerializer(data=request.data)
if data.is_valid():
try:
ticket = Ticket.objects.get(
public_id=data.validated_data.get('public_id'))
except Ticket.DoesNotExist or Ticket.MultipleObjectsReturned:
raise TicketNotFound
if ticket.is_used or ticket.event.end_date < get_current_time():
raise TicketIsExpired()
if request.user != ticket.event.host:
raise UserPermission
ticket.is_used = True
ticket.save()
return response()
raise ValidationError(
error_list=error_many_list_serializer(data.errors))
def refund_all_event_users(event):
if event.is_responsible:
payments = Payment.objects.filter(event=event, user__is_company=False)
if not payments:
raise NoPaymentIsMade
for i in payments:
try:
refund = stripe.Refund.create(
payment_intent=i.refund_id,
)
except Exception as e:
raise StripeError()
i.is_refunded=True
i.save()
event.all_user_payments_refunded = True
event.save()
return response()
raise EventIsNotResponsible()
def delete(self, request, public_id=None):
if public_id:
event = Event.objects.filter(public_id=public_id).first()
if event:
if Ticket.objects.filter(event=event):
if event.is_responsible:
try:
refund_all_event_users(event)
except NoPaymentIsMade as e:
pass
except StripeError() as e:
raise e
else:
raise CannotDeleteEventHavingTickets()
event.delete()
return response()
raise EventNotFound
raise NotFound
def get(self, request, public_id):
page = request.GET.get('page', 1)
event = Event.objects.filter(public_id=public_id).first()
if not event:
raise EventNotFound
tickets = Ticket.objects.filter(event=event)
tickets = TicketFilter(request.GET, queryset=tickets).qs
paginator = Paginator(tickets, settings.TICKET_PAGE_SIZE)
try:
tickets = paginator.page(page)
except PageNotAnInteger:
tickets = paginator.page(1)
page = 1
except EmptyPage:
tickets = paginator.page(paginator.num_pages)
page = paginator.num_pages
return response(
data={
"tickets": [i.serialize(extra_info=False) for i in tickets],
"current_page": page,
"last_page": paginator.num_pages,
"has_next": tickets.has_next(),
"has_previous": tickets.has_previous()
})
def inner_function(*args, **kwargs):
try:
return func(*args, **kwargs)
except AuthException as e:
return response(errors=[e.serialize()], success=False)
def get(self, request):
user = request.user
address = user.address
if address is not None:
return response(data={"address": address.serialize()})
raise UserHasNoAddress()
def get(self, request):
return response()
def inner_function(*args, **kwargs):
try:
return func(*args, **kwargs)
except (AuthException, UserCrudException, ValidationError) as e:
return response(errors=[e.serialize()], success=False)
def get(self, request):
return response(data=request.user.serialize(extra_info=True))
