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))