def post(self, request):
Serializer = UserSerializer(data=request.data)
if Serializer.is_valid(raise_exception=True):
Serializer.save()
# generate a token and login
email = request.data['email']
password = request.data['password']
user = User.objects.filter(email=email).first()
payload = {
'id': user.id,
'exp': datetime.datetime.utcnow() + datetime.timedelta(minutes=60),
'iat': datetime.datetime.utcnow()
}
token = jwt.encode(payload, 'secret',algorithm='HS256').decode('utf-8')
response = Response({}, status=status.HTTP_200_OK)
response.set_cookie(key='jwt', value=token, httponly=True)
response.data = {
'jwt': token,
'id': user.id
}
return response
return Response(Serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def register(s, f):
Serializer = serializers.LoginSerializer(data=f.POST)
if Serializer.is_valid(raise_exception=True):
Serializer.save()
return response.Response(Serializer.data)
else:
return response.Response(Serializer.errors)
def post(self, request, user_id, advisor_id):
recieved_data = request.data
recieved_data["advId"] = advisor_id
recieved_data["userId"] = user_id
Serializer = BookingSerializer(data=recieved_data)
if Serializer.is_valid():
Serializer.save()
return Response(None, status=status.HTTP_200_OK)
return Response(Serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
Serializer = AdvisorSerializer(data=request.data)
if Serializer.is_valid():
Serializer.save()
test_res = {}
test_res["name"] = Serializer.data["name"]
test_res["picture_url"] = Serializer.data["picture_url"]
return Response(test_res, status=status.HTTP_200_OK)
return Response(Serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def perform_create(self, serializer: Serializer) -> None:
try:
message, signature = extract_authorization_components(self.request)
address = extract_address_from_authorization(message, signature)
except Exception:
logger.exception('Failure processing credentials')
raise APIException('Invalid credentials')
if serializer.validated_data['address'] != address:
raise ValidationError('Addresses do not match')
serializer.save()
def perform_create(self, serializer: Serializer):
if not serializer.validated_data['timeslot']:
start_time: datetime = serializer.validated_data['start_time']
duration = serializer.validated_data['duration']
subject = serializer.validated_data['subject']
timeslot = util.find_matching_timeslot(start_time, duration,
subject, self.request.user,
TimeSlot.objects.all())
if timeslot:
serializer.initial_data['timeslot'] = timeslot.id
serializer.run_validation(serializer.initial_data)
serializer.validated_data['timeslot'] = timeslot
else:
raise ValidationError(
{'timeslot': _("Couldn't find matching timeslot!")})
serializer.save()
def post(self, request, format='json'):
Serializer = UserSerializer(data=request.data) #serializer object
if Serializer.is_valid():
user = Serializer.save()
if user:
return Response(Serializer.data, status=status.HTTP_201_CREATED)
return Response(Serializer.errors, status=status.HTTP_400_BAD_REQUEST) #handles the bad request
def perform_create(self, serializer: Serializer):
if serializer.is_valid():
password = serializer.validated_data.get('password')
new_user = serializer.save()
new_user.set_password(password)
new_user.save()
return Response(serializer.data, status.HTTP_201_CREATED)
super().perform_create(serializer)
def perform_update(self, serializer: Serializer) -> None:
instance = serializer.save()
if not self.AUDITOR_EVENT_TYPES:
return instance
event_type = self.AUDITOR_EVENT_TYPES.get('UPDATE')
if event_type and is_user(self.request.user):
auditor.record(event_type=event_type,
instance=instance,
actor_id=self.request.user.id,
actor_name=self.request.user.username)
def perform_update(self, serializer: Serializer):
if serializer.is_valid(raise_exception=True):
previous_instance = self.get_object() # type: Domain
registration_period = serializer.validated_data[
'registration_period']
if registration_period and registration_period != previous_instance.registration_period:
# registration period changed, update price cycle
service = previous_instance.service
new_cycle = service.product.cycles.filter(
cycle_multiplier=registration_period).first()
if new_cycle:
service.cycle = new_cycle
service.save()
else:
raise ValidationError({
'registration_period':
_('No price defined for this registration period. Check TLD pricing'
)
})
new_name = serializer.validated_data['name']
if new_name and new_name != previous_instance.name:
if not DomainUtils.validate_domain_name(domain_name=new_name):
raise ValidationError({'name': _('Invalid domain name')})
try:
new_tld_name = DomainUtils.get_tld_name(new_name)
except ValueError:
new_tld_name = None
if previous_instance.tld.name != new_tld_name:
raise ValidationError({
'name':
_('New domain name should have the same TLD({})').
format(previous_instance.tld.name)
})
serializer.save()
def perform_update(self, serializer: serializers.Serializer) -> None:
serializer.save(
modified_by=self.request.user.username,
modified_on=datetime.now(),
)
def perform_create(self, serializer: Serializer):
email_address = serializer.save()
signals.email_added.send(sender=self.request.user.__class__,
request=self.request,
user=self.request.user,
email_address=email_address)
def perform_create(self, serializer: serializers.Serializer):
serializer.save(owner=self.request.user)
def save_hashtag_and_response(self, serializer: Serializer) -> Response:
serializer.save()
return self.json_success_response(
message={MESSAGE_JSON_KEY: "Hashtag created successfully"},
hashtag=serializer.data)
