def post(self, request):
"""
Handles the POST request made to the `/accounts/` URL.
This view will take the `data` property from the `request` object,
deserialize it into a `User` object and store in the DB.
Returns a 201 (successfully created) if the user is successfully
created, otherwise returns a 400 (bad request)
:param request:
:return:
"""
serializer = UserSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
data = serializer.data
# Create a new user using the username contained in the data dict
user = User.objects.create(username=data["username"])
# User the set password method to create a hashed password
# using the password provided in the data dict
user.set_password(data["password"])
# Finally save the new user object
user.save()
return Response(data, status=status.HTTP_201_CREATED)
def post(self, request):
"""
Handles the POST request made to the `/accounts/` URL.
This view will take the `data` property from the `request` object,
deserialize it into a `User` object and store in the DB.
Returns a 201 (successfully created) if the user is successfully
created, otherwise returns a 400 (bad request)
"""
serializer = UserSerializer(data=request.data)
# Check to see if the data in the `request` is valid.
# If the cannot be deserialized into a Todo object then
# a bad request respose will be returned.
# Else, save the data and return the data and a successfully
# created status
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
data = serializer.data
# Create a new user using the `username` contained in
# the `data` dict
user = User.objects.create(username=data["username"])
# Use the `set_password` method to create a hashed password
# using the password provided in the `data` dict
user.set_password(data["password"])
# Finally, save the new `user` object
user.save()
return Response(data, status=status.HTTP_201_CREATED)
def post(self, request, format=None):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
user.set_password(request.data['password'])
user.save()
return Response(serializer.data, status=201)
return Response(serializer.errors, status=400)
def post(self, request):
serialized = UserSerializer(data=request.DATA)
if serialized.is_valid():
user = User.objects.create_user(**request.DATA)
data = {'token': Token.objects.get(user=user).key}
return Response(data, status=status.HTTP_201_CREATED)
else:
return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def register(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = User.objects.create_user(**serializer.validated_data)
token = Token.create_token(user.id)
data = {
'username': user.username,
'token': token
}
return Response(data, status=201)
return Response(serializer.errors, status=400)
def post(self, request, format='json'):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
if user:
token = Token.objects.create(user=user)
json = serializer.data
json['token'] = token.key
return Response(json, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def setUp(self):
self.url = reverse('auth')
# User info
self.username = '******'
self.email = '*****@*****.**'
self.password = '******'
# make sure our example data is valid
serializer = UserSerializer(data={'username': self.username,
'email': self.email,
'password': self.password})
if serializer.is_valid():
self.user = serializer.save()
else:
self.fail()
class AttendanceSerializer(serializers.ModelSerializer):
user = UserSerializer(read_only=True)
team = TeamSerializer(read_only=True)
class Meta:
model = Attendance
fields = "__all__"
read_only_fields = ('created', 'updated')
class ReferenceSerialaizer(serializers.ModelSerializer):
reference_type_id = Reference_Type_Serializer(read_only=True)
user = UserSerializer(read_only=True)
class Meta:
model = Reference
fields = ('id', 'reference_type_id', 'user', 'reference_file',
'created_at')
def profile(request,user_pk):
user = get_object_or_404(User, pk=user_pk)
userserial = UserSerializer(user)
likemovies = user.likemovie_set.filter(score__gte=4)
likeserial = UserLikeMovieSerializer(likemovies, many=True)
return Response([userserial.data,likeserial.data])
class ProductSerializer(serializers.ModelSerializer):
# category=CategorySerializer()
category = serializers.ReadOnlyField(source='category.name') #get the name
likes = UserSerializer(many=True) #nested
class Meta:
model = Product
fields = '__all__'
def test_fields(self):
serializer = UserSerializer()
self.assert_fields_required(True, serializer, self.required_fields)
self.assert_fields_required(False, serializer,
self.not_required_fields)
self.assertEqual(
len(serializer.fields),
len(self.required_fields) + len(self.not_required_fields))
def get(self, request, format='json'):
username = "******"
password = "******"
email = "*****@*****.**"
user = authenticate(request, username=username, password=password)
login(request, user)
serializer = UserSerializer(user)
return JsonResponse(serializer.data, safe=False)
def tweet_list_view(request, *args, **kwargs):
qs = Tweet.objects.all()
username = UserSerializer(request.user).data.get('username')
print(username)
if username != None:
qs = qs.filter(user__username__iexact=username)
serializer = TweetSerializer(qs, many=True)
return Response(serializer.data, status=200)
class ArticleSerializer(serializers.ModelSerializer):
user = UserSerializer(required=False)
movie = MovieSerializer(required=False)
class Meta:
model = Article
fields = "__all__"
read_only_fields = ['id']
def users(request):
try:
users = User.objects.all()
serializer = UserSerializer(users, many=True)
return Response(data=serializer.data, status=status.HTTP_200_OK)
except:
return Response(status=status.HTTP_500_INTERNAL_SERVER_ERROR)
class ChallengeCommentSerializer(serializers.ModelSerializer):
author = UserSerializer(read_only=True)
replies = RecursiveField(many=True, read_only=True)
class Meta:
model = ChallengeComment
fields = ('id', 'content', 'author', 'replies')
read_only_fields = ('id', 'author', 'replies')
class ChanelSerializer(serializers.ModelSerializer):
owner = UserSerializer(read_only=True)
author = UserSerializer(read_only=True, many=True)
def update(self, instance, validated_data):
instance.description = validated_data.get('description',
instance.description)
instance.identifier = validated_data.get('identifier',
instance.identifier)
instance.law = validated_data.get('law', instance.law)
instance.title = validated_data.get('title', instance.title)
instance.save()
return instance
class Meta:
model = Chanel
fields = '__all__'
def get(self, request, pk, format=None):
user_detail = self.get_object(pk)
serializer = UserSerializer(user_detail)
# data_with_link = dict(serializer.data)#["member"] = 'groups/{}/members/'.format(pk)
# links = {'members': 'api/v1/groups/{}/members/'.format(pk)}
# data_with_link['links'] = links
data_dict = {"data": serializer.data, "status": 200}
return Response(data_dict, status=status.HTTP_200_OK)
def post(self, request, *args, **kwargs):
serializer = self.serializer_class(
data=request.data, context={"request": request}
)
serializer.is_valid(raise_exception=True)
user = serializer.validated_data["user"]
token, created = Token.objects.get_or_create(user=user)
return Response({"key": token.key, "user": UserSerializer(instance=user).data})
class QustionSerializer(serializers.ModelSerializer):
tags = TagSerializer(many=True)
answers = AnswerSerializer(many=True, required=False, allow_null=True)
user = UserSerializer()
comment = CommentSerializer(many=True)
class Meta:
model = Question
def enrollusers(self, request, *args, **kwargs):
queryset = Enroll.objects.filter(
lesson__created_by=self.request.user).values_list('user',
flat=True)
users = User.objects.filter(email__in=queryset)
page = self.paginate_queryset(users)
serializers = UserSerializer(page, many=True)
return self.get_paginated_response(serializers.data)
def setUp(self):
self.user = User.objects.first()
Task.objects.create(
done=True,
content="Test",
user=self.user,
)
self.serializer = UserSerializer(self.user)
class ArticleSerializer(serializers.ModelSerializer):
user = UserSerializer(required=False)
created_at = serializers.DateTimeField(required=False)
class Meta:
model = Article
fields = '__all__'
read_only_fields = ('id', 'user', 'created_at', 'updated_at')
class RetrieveDeleteSerializer(UpdateCreateTaskSerializer):
''' Serializer for tasks model '''
assigned_to = UserSerializer(many=False)
class Meta:
model = Task
fields = ('id', 'assigned_to', 'team', 'name', 'description', 'status',
'deadline', 'created')
class ReviewDetailSerializer(serializers.ModelSerializer):
writer = UserSerializer(required=False)
movie = MovieSerializer(required=False)
class Meta:
model = Review
fields = '__all__'
class OrderCreateSerializer(serializers.ModelSerializer):
user = UserSerializer(required=False)
reward = RewardSerializer(required=False)
card = CardSerialiser(required=False)
class Meta:
model = Order
fields = '__all__'
class LikeMovieSerializer(serializers.ModelSerializer):
user = UserSerializer(required=False)
class Meta:
model = LikeMovie
fields = '__all__'
read_only_fields = ('id', 'user')
class MemesSerializer(serializers.ModelSerializer):
owner = UserSerializer(many=True, read_only=True)
tags = TagSerializer(many=True, read_only=True)
class Meta:
model = Memes
fields = '__all__'
depth = 1
class EmotionSerializer(serializers.ModelSerializer):
id = serializers.IntegerField(required=False)
user = UserSerializer(read_only=True)
name = serializers.CharField(max_length=100)
class Meta:
model = Emotion
fields = ('id', 'name', 'user')
def has_permission(self, request, view):
user = UserSerializer(request.user)
role = user.data['role']
if role == 'HOD':
return True
else:
return False
def has_permission(self, request, view):
user = UserSerializer(request.user)
role = user.data['role']
if role == 'HOD' or role == 'student_leader' or role == 'Administrator':
return True
else:
return False
def post(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.save()
return Response({
"user": UserSerializer(user, context=self.get_serializer_context()).data,
"token": AuthToken.objects.create(user)[1]
})
def has_permission(self, request, view):
user = UserSerializer(request.user)
role = user.data['role']
id = user.data['id']
if role == 'Administrator' or id == '1':
return True
else:
return False
def jwt_response_payload_handler(token, user=None, request=None):
# requset needs to be passed in the context, error otherwise
return {
'token': token,
'user': UserSerializer(user, context={
'request': request
}).data
}
class OrderSerializer(serializers.ModelSerializer):
user = UserSerializer()
reward = RewardSerializer()
card = CardSerialiser()
class Meta:
model = Order
fields = '__all__'
class AsesorSerializer(serializers.ModelSerializer):
reclutador = UserSerializer(read_only=True,
default=serializers.CurrentUserDefault())
class Meta:
model = Asesor
fields = '__all__'
def setUp(self):
# url
self.user_list = 'api:user-list'
self.user_detail = 'api:user-detail'
# User info
self.username = '******'
self.email = '*****@*****.**'
self.password = '******'
# make sure our example data is valid
serializer = UserSerializer(data={'username': self.username,
'email': self.email,
'password': self.password})
if serializer.is_valid():
self.user = serializer.save()
else:
self.fail()
def post(self, request):
logger.info("UpdatePasswordView.post is called. User: {0}".format(request.user.log_guid))
# TODO: check if front end sends a json file or normal request
data = request.data
update_password_serializer = self.serializer_class(data=data)
if update_password_serializer.is_valid():
password = update_password_serializer.validated_data['password']
account = authenticate(email=request.user.email, password=password)
if account is not None:
if account.is_active:
new_password = update_password_serializer.validated_data['new_password']
try:
# we use partial to avoid passing required fields into serializer
serializer = UserSerializer(account, data={'password': new_password}, partial=True)
if serializer.is_valid():
serializer.save()
account = authenticate(email=request.user.email, password=new_password)
login(request, account)
logger.info(self.msgs['finish_success'].format(request.user.log_guid))
return Response({
'status': _('Success'), 'message': self.msgs['update_pass_success']},
status=status.HTTP_200_OK)
else:
logger.error(self.errs['ser_not_valid'].format(data))
return Response({'status': _('Bad request'), 'message': serializer.errors},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
logger.exception(self.errs['exception'].format(e.message))
return Response({'status': _('Bad request'), 'message': self.msgs['internal_server_error']},
status=status.HTTP_400_BAD_REQUEST)
else:
logger.error(self.errs['user_inactive'].format(request.user.log_guid))
return Response({'status': _('Unauthorized'), 'message': self.msgs['cannot_update_pass']},
status=status.HTTP_401_UNAUTHORIZED)
else:
logger.error(self.errs['combination_invalid'])
return Response({
'status': _('Unauthorized'), 'message': self.msgs['combination_invalid']},
status=status.HTTP_401_UNAUTHORIZED)
else:
logger.error(update_password_serializer.errors)
return Response({'status': 'Bad request', 'message': self.msgs['password_mismatch'],
'errors': 'Validation error'},
status=status.HTTP_400_BAD_REQUEST)
def register(request):
"""
Endpoint for registration.
Does not require any permissions, so that anyone can access it.
"""
USER_FIELDS = ['username', 'password', 'email', 'role']
serialized = UserSerializer(data=request.data)
if serialized.is_valid(raise_exception=True):
user_data = {
field: data
for (field, data) in request.data.items()
if field in USER_FIELDS
}
user = User.objects.create_user(
**user_data
)
return Response(
UserSerializer(instance=user, context={'request': request}).data,
status=status.HTTP_201_CREATED,
)
def post(self, request, format='json'):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
#print("Valid")
user = serializer.save()
if user:
if request.data["isStudent"] == 1:
new_student = Student(user=user, contact_no=request.data["contact_no"])
new_student.save()
elif request.data["isStudent"] == 0:
new_teacher = Teacher(user=user, contact_no=request.data["contact_no"])
new_teacher.save()
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
token = Token.objects.create(user=user)
json = serializer.data
json['token'] = token.key
return Response(json, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def setUp(self):
self.token_list = 'api:token-list'
self.token_detail = 'api:token-detail'
# Clients cannot be created via view or serialzier
self.name = 'reddit'
self.api_url = 'https://oauth.reddit.com/api/v1/'
self.authorize_url = 'https://www.reddit.com/api/v1/'
self.token_url = 'https://www.reddit.com/api/v1/access_token/'
self.client_id = 'some-client-id'
self.client_secret = 'some-secret'
self.redirect_uri = 'http://*****:*****@example.com'
self.password = '******'
# make sure our example data is valid
serializer = UserSerializer(data={'username': self.username,
'email': self.email,
'password': self.password})
if serializer.is_valid():
self.user = serializer.save()
else:
self.fail()
def post(self, request):
data = json.loads(request.body)
guid = data.get('guid', None)
logger.info("SetPasswordView.post is called. GUID: {0}".format(guid))
password_serializer = PasswordSerializer(data=data, partial=True)
if not password_serializer.is_valid():
return Response({
'status': _('Bad request'),
'message': self.msgs['password_mismatch'],
'errors': 'Validation error'
}, status=status.HTTP_400_BAD_REQUEST)
try:
user_uid = UserUID.objects.get(guid=guid)
except ObjectDoesNotExist:
logger.exception(self.errs['GUID_invalid'].format(guid))
return Response({
'status': _('Bad request'),
'message': self.msgs['activation_invalid']
}, status=status.HTTP_400_BAD_REQUEST)
now_offset_aware = timezone.make_aware(datetime.datetime.utcnow(), timezone.get_current_timezone())
if user_uid.expiration_date < now_offset_aware:
logger.error(self.errs['GUID_expired'].format(guid, user_uid.expiration_date, now_offset_aware))
return Response({
'status': _('Bad request'),
'message': self.msgs['activation_invalid']
}, status=status.HTTP_400_BAD_REQUEST)
try:
account = User.objects.get(id=user_uid.user_id)
except ObjectDoesNotExist:
logger.exception(self.msgs['GUID_invalid'].format(guid))
return Response({
'status': _('Fail'),
'message': self.msgs['internal_server_error']
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
if account is not None:
se_data = dict()
se_data['password'] = password_serializer.validated_data['new_password']
se_data['confirm_password'] = password_serializer.validated_data['confirm_password']
se_data['email'] = account.email
se_data['username'] = account.username
se_data['log_guid'] = account.log_guid
try:
with transaction.atomic():
serializer = UserSerializer(account, data=se_data)
if serializer.is_valid():
serializer.save()
# We need to mark the forgotpassword GUID as expired
uid_data = dict()
uid_data['guid'] = guid
uid_data['user'] = user_uid.user_id
uid_data['expiration_date'] = datetime.datetime.utcnow()
uidSerializer = UserUIDSerializer(user_uid, data=uid_data)
if uidSerializer.is_valid():
uidSerializer.save()
logger.info(self.msgs['finish_success'].format(guid))
return Response({
'status': _('Success'),
'message': self.msgs['update_pass_success']
}, status=status.HTTP_200_OK)
else:
logger.error(self.errs['ser_not_valid'].format(guid, user_uid.user_id, uid_data['expiration_date']))
return Response({
'status': _('Fail'),
'message': self.msgs['internal_server_error']
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
else:
logger.error(self.errs['server_error'])
return Response({
'status': _('Fail'),
'message': self.msgs['internal_server_error']
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
except Exception as e:
logger.exception(self.errs['exception'].format(guid, e.message))
return Response({
'status': _('Bad request'),
'message': self.msgs['internal_server_error']
}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
else:
logger.exception(self.errs['GUID_none'].format(guid))
return Response({
'status': _('Bad request'),
'message': self.msgs['activation_invalid']
}, status=status.HTTP_400_BAD_REQUEST)
