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 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, 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 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 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 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 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 delete(self, request, public_id):
event = request.event
data = EventCompanyUser(data=request.data)
if data.is_valid():
if data.user == request.user and not data.user == event.host:
event.users.remove(data.user)
raise UserPermission()
raise ValidationError(
error_list=error_many_list_serializer(data.errors))
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 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 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 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):
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 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 validate_passwords(self, user):
if self.is_valid():
if user.check_password(self.validated_data.get('old_password')):
if not self.validated_data.get(
'password1') == self.validated_data.get('password2'):
raise ValidationErrorBase(
field="password2", message='Passwords do not match.')
user.set_password(self.validated_data.get('password1'))
user.reset_password_attempts = 0
user.save()
return
user.reset_password_attempts += 1
user.save()
# todo check this
if user.reset_password_attempts == RESET_PASSWORD_ATTEMPTS:
user.reset_password_attempts = 0
self.session.expire_session()
raise SessionAlreadyExpired
raise ValidationErrorBase(
field="old_password",
message='Provided password is incorrect.')
raise ValidationError(
error_list=error_many_list_serializer(self.errors))
