def test_update_user(self):
self.test_create_user()
username_to_update = 'updatedUserSerializer'
first_name_to_update = "UpdatedUser"
last_name_to_update = "UsingSerializer2"
user_data_to_update = {
'username': username_to_update,
'email': self.email,
'password': '******',
'first_name': first_name_to_update,
'last_name': last_name_to_update,
"profile": {
"role": Profile.PHYSICIAN
}
}
user_in_database = User.objects.get(email=self.email)
user_serialized = UserSerializer(instance=user_in_database,
data=user_data_to_update)
user_serialized_valid = user_serialized.is_valid()
user_created = user_serialized.save()
user_in_database_after_updated = User.objects.get(email=self.email)
self.assertTrue(user_serialized_valid)
self.assertEquals(user_in_database_after_updated, user_created)
self.assertEquals(user_in_database_after_updated.username,
username_to_update)
self.assertEquals(user_in_database_after_updated.first_name,
first_name_to_update)
self.assertEquals(user_in_database_after_updated.last_name,
last_name_to_update)
def register(self, request):
'''
Allows users to register themselves. Being then put on a waiting list to be approved.
'''
if request.user.is_authenticated():
return Response(
{
'error':
"An already registered user can't register new users!"
}, status.HTTP_400_BAD_REQUEST)
dataRequest = request.data.copy()
password = dataRequest.pop('password', None)
email = dataRequest.get('email', None)
if email != None and password != None:
email = email.lower()
try:
user = User.objects.get(email=email)
return Response(
{'error': "An user with this email already exists"},
status=status.HTTP_400_BAD_REQUEST)
except User.DoesNotExist:
if (not 'username' in dataRequest):
dataRequest['username'] = email[:30]
dataRequest['email'] = email
serializer = UserSerializer(data=dataRequest,
context={'request': request})
user_validated = serializer.is_valid(raise_exception=True)
if user_validated:
new_user = serializer.save()
new_user.set_password(password)
new_user.is_active = False
new_user.save()
staff = User.objects.filter(is_staff=True)
History.new(event=History.ADD,
actor=new_user,
object=new_user,
authorized=staff)
return Response(serializer.data,
status=status.HTTP_201_CREATED)
return Response({'error': "User details invalid"},
status=status.HTTP_400_BAD_REQUEST)
return Response(
{
'error':
"Email and password are mandatory fields on registering a new user"
},
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format='json'):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.save()
# generating tokens for the user
if user:
token = Token.objects.create(user=user)
json = serializer.data
json['token'] = token.key
print(token)
return Response(serializer.data,
status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
form = FileSerializer(data=request.data)
if form.is_valid():
input = form.save()
path = os.path.join(settings.MEDIA_ROOT, str(input.file))
workbook = xlrd.open_workbook(filename=path)
sheet = workbook.sheet_by_index(0)
if sheet.nrows < 2:
return Response({'message': 'There is no users in file'}, status=status.HTTP_400_BAD_REQUEST)
else:
for i in range(2, sheet.nrows):
student_id = sheet.cell(i, 0).value
last_name = sheet.cell(i, 1).value
first_name = sheet.cell(i, 2).value
major_string = sheet.cell(i, 4).value
email = sheet.cell(i, 6).value
if major_string.lower().strip() == 'программная инженерия':
major = Major.SE.name
else:
major = Major.AMI.name
username = email.split("@")[0].strip()
data = {
'username': username,
'first_name': first_name,
'last_name': last_name,
'email': email,
'password': student_id,
}
serialized = UserSerializer(data=data)
if serialized.is_valid():
user = serialized.save()
response = serialized.data
UserPreferences.objects.create(
user=user,
user_preference=Preference.STUDENT.name
)
UserMajor.objects.create(
user=user,
user_major=major
)
Mark.objects.create(user=user, first_name=user.first_name,
second_name=user.last_name,
major=major)
UserStudentID.objects.create(user=user, student_id=student_id)
del response['password']
del response['first_name']
del response['last_name']
return Response({"status": "OK"}, status=status.HTTP_201_CREATED)
class ReviewReadSerializer(serializers.ModelSerializer):
user = UserSerializer()
book = BookWriteSerializer()
class Meta:
model = Review
fields = '__all__'
def login(self, request):
serializer = LoginSerializer(data=request.data)
if not serializer.is_valid():
return Response(
{
"success": False,
"massage": "Please check input.",
"errors": serializer.errors,
},
status=400)
#validation ok , login
username = serializer.validated_data['username']
password = serializer.validated_data['password']
if not User.objects.filter(username=username).exists():
return Response(
{
"success": False,
"massage": "User does not exists."
},
status=400)
user = django_authenticate(username=username, password=password)
if not user or user.is_anonymous:
return Response(
{
"success": False,
"massage": "Username and password does not match.",
},
status=400)
django_login(request, user)
return Response({
"success": True,
"user": UserSerializer(instance=user).data
})
def get_all_user_api_view(request):
try:
users = User.objects.all()
profile = Profile.objects.all()
except ObjectDoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
staff_user = request.user.is_staff
admin_user = request.user.is_admin
if not staff_user and not admin_user:
return Response(
{'Response': 'You do not have the permission to view this'})
if request.method == 'GET':
user_serializer = UserSerializer(users, many=True)
profile_serializer = ProfileSerializer(profile, many=True)
return JsonResponse(
{
'users': user_serializer.data,
'profile': profile_serializer.data
},
safe=False,
status=status.HTTP_200_OK)
def login(self, request):
# get username and password from request
# data就是用户post的request中的数据
# check request
serializer = LoginSerializer(data=request.data)
if not serializer.is_valid(): # 如果登录出错
return Response(
{
"success": False,
"message": "Please check input.",
"errors": serializer.errors,
},
status=400)
# validation ok
# check password
username = serializer.validated_data['username']
password = serializer.validated_data['password']
user = django_authenticate(username=username, password=password)
if not user or user.is_anonymous:
return Response(
{
"success": False,
"message": "Username and password does not match.",
},
status=400)
# login
django_login(request, user)
return Response({
"success": True,
"user": UserSerializer(user).data,
})
def signup(self, request):
"""
username, email, password to signup
:param request:
:return:
"""
serializer = SignupSerializer(data=request.data)
if not serializer.is_valid():
return Response(
{
'success': False,
'message': "Please check input",
'errors': serializer.errors,
},
status=400)
user = serializer.save()
# create UserProfile object
user.profile
django_login(request, user)
return Response({
'success': True,
'user': UserSerializer(user).data,
})
def create(self, request):
serializer = LoginSerializer(data=request.data)
if not serializer.is_valid():
return Response(
{
'success': False,
'message': 'Please check input',
'errors': serializer.errors,
},
status=400)
username = serializer.validated_data['username']
password = serializer.validated_data['password']
user = authenticate(username=username, password=password)
if not user or user.is_anonymous:
return Response(
{
'success': False,
'message': 'username and password does not match',
},
status=400)
login(request, user)
return Response({
'success': True,
'user': UserSerializer(user).data,
})
def get(self,request,event_id,format=None): # 'event_id'is passed as extra arguement to get()-->check url
event_id=self.kwargs['event_id']
event_object=get_object_or_404(Event,id=event_id)#to check event exists
print(event_object)
#below query will return only one object if it exists
try:
highest_bid_object=Bid.objects.filter(event_id=event_id).order_by("-bid_price")[0:1].get()
if request.user.is_staff:
#admin can check details of user placing highest bid at the moment
highest_bid_user=User.objects.get(id=highest_bid_object.user_id)
user_serializer=UserSerializer(highest_bid_user)#serializing object
return Response({"user":user_serializer.data,"highest_bid":highest_bid_object.bid_price})
else:
return Response({"user":None,"highest_bid": highest_bid_object.bid_price})
except ObjectDoesNotExist:
return Response({"detail":"not bids received for this event"},status=status.HTTP_404_NOT_FOUND)
class FollowingSerializer(serializers.ModelSerializer):
user = UserSerializer(source='to_user')
created_at = serializers.DateTimeField()
class Meta:
model = Friendship
fields = ('user', 'created_at')
class MessageSerializer(serializers.ModelSerializer):
class Meta:
model = Message
fields = ('id', 'subject', 'body', 'sender', 'recipients', 'parent',
'reply_to', 'sent_at', 'sender_deleted_at', 'created_at',
'updated_at', 'files', 'children', 'has_unread', 'is_unread',
'last_activity', 'quote', 'project', 'type')
read_only_fields = ('sender', 'files', 'recipients', 'children',
'has_unread', 'is_unread', 'last_activity',
'quote', 'project', 'type')
sender = UserSerializer(read_only=True)
files = MessageFileSerializer(many=True, read_only=True)
recipients = MessageRecipientSerializer(many=True,
read_only=True,
source='message_recipients')
children = MessageChildrenManyRelatedField(
child_relation=MessageChildrenField())
has_unread = fields.SerializerMethodField()
is_unread = fields.SerializerMethodField()
last_activity = fields.SerializerMethodField()
quote = QuoteSerializer(required=False, read_only=True)
def get_has_unread(self, obj):
return getattr(obj, 'has_unread', None)
def get_is_unread(self, obj):
return getattr(obj, 'is_unread', None)
def get_last_activity(self, obj):
return getattr(obj, 'last_activity', None)
def login(self, request):
serializer = LoginSerializer(data=request.data)
if not serializer.is_valid():
return Response(
{
'success': False,
'message': "Please check input",
'errors': serializer.errors,
},
status=400)
username = serializer.validated_data['username']
password = serializer.validated_data['password']
# queryset = User.objects.filter(username=username)
# print(queryset.query)
user = django_authenticate(username=username, password=password)
if not user or user.is_anonymous:
return Response(
{
'success': False,
'message': "username and password does not match",
},
status=400)
django_login(request, user)
return Response({
'success': True,
'user': UserSerializer(instance=user).data
})
def login(self, request):
serializer = LoginSerializer(data=request.data)
if not serializer.is_valid():
return Response(
{
"success": False,
"message": "Input is not valid. Please check input",
"errors": serializer.errors,
},
status=400)
username = serializer.validated_data['username']
password = serializer.validated_data['password']
user = django_authenticate(username=username, password=password)
if not user or user.is_anonymous:
return Response(
{
"success":
False,
"message":
"Username and password are not matched. Please try again",
},
status=400)
django_login(request, user)
return Response({
"success": True,
"user": UserSerializer(user).data,
})
class UserProfileSerializer(serializers.ModelSerializer):
user = UserSerializer()
class Meta:
permission_classes = [permissions.IsAuthenticated]
model = Profile
exclude = ['id']
class OrderSerializer(serializers.ModelSerializer):
items = OrderItemSerializer(many=True, read_only=True)
customer = UserSerializer(read_only=True)
url = serializers.CharField(source='get_api_url', read_only=True)
class Meta:
model = BaseOrder
fields = ['id', 'url', 'customer', 'total', 'subtotal', 'status', 'is_valid','items']
class QuestionSerializer(serializers.ModelSerializer):
answers = AnswerSerializer(many=True, read_only=True)
user = UserSerializer(read_only=True) # read only mean
class Meta:
model = Question
fields = "__all__"
def signup(self, request):
serializer = SignupSerializer(data=request.data)
if not serializer.is_valid():
return Response(
{
'success': False,
'message': 'Please check input',
'errors': serializer.errors
},
status=400)
user = serializer.save()
# create a new profile for the new user
user.profile
# automatically login
django_login(request, user)
return Response(
{
'success': True,
'user': UserSerializer(instance=user).data
},
status=201)
def retrieve(self, request, pk=None):
if pk == 'i':
return Response(
UserSerializer(request.user, context={
'request': request
}).data)
return super(UserViewSet, self).retrieve(request, pk)
class TweetSerializer(serializers.ModelSerializer):
user = UserSerializer(read_only=True)
date_display = serializers.SerializerMethodField()
timesince = serializers.SerializerMethodField()
parent = ParentTweetModelSerializer(read_only=True)
likes = serializers.SerializerMethodField()
did_like = serializers.SerializerMethodField()
class Meta:
model = Tweet
fields = [
'id', 'user', 'content', 'publish', 'date_display', 'timesince',
'parent', 'likes', 'did_like'
]
def get_date_display(self, obj):
return obj.publish.strftime("%b %d, at %H:%M")
def get_timesince(self, obj):
return timesince(obj.publish) + " ago"
def get_likes(self, obj):
return obj.liked.all().count()
def get_did_like(self, obj):
request = self.context.get("request")
user = request.user
if user.is_authenticated:
if user in obj.liked.all():
return True
return False
class ParentTweetSerializer(serializers.ModelSerializer):
user = UserSerializer(read_only=True)
date_display = serializers.SerializerMethodField()
timesince = serializers.SerializerMethodField()
likes = serializers.SerializerMethodField()
did_like = serializers.SerializerMethodField()
class Meta:
model = Tweet
fields = ('user', 'content', 'time', 'date_display', 'timesince', 'id',
"likes", "did_like")
def get_did_like(self, obj):
try:
request = self.context.get("request")
user = request.user
if user.is_authenticated:
if user in obj.liked.all():
return True
return False
except:
pass
def get_date_display(self, obj):
return obj.time.strftime("%b %d, %Y | %I:%M %p")
def get_timesince(self, obj):
return timesince(obj.time) + " ago"
def get_likes(self, obj):
return obj.liked.all().count()
def my_jwt_response_handler(token, user=None, request=None):
return {
'token': token,
'user': UserSerializer(user, context={
'request': request
}).data
}
class EventSerializer(serializers.ModelSerializer):
user = UserSerializer(read_only=True)
address = serializers.SerializerMethodField()
def get_address(self, instance):
return "{line1} {line2} {city}-{postalCode}, {country}".format(
line1=instance.line1,
line2=instance.line2,
postalCode=instance.postalCode,
city=instance.city,
country=instance.country)
class Meta:
model = EventModel
fields = (
'user',
'id',
'title',
'slug',
'description',
'image',
'company',
'hostName',
'category',
'address',
'date_of_event',
)
lookup_field = 'slug'
extra_kwargs: {'id': {'lookup_field': 'slug'}}
def create(self, validated_data):
user = self.context['request'].user
return EventModel.objects.create(user=user, **validated_data)
def post(self, request, *args, **kwargs):
user = User.get_user_by_uuid(request.user.id)
if user:
user.first_name = request.data['first_name']
user.last_name = request.data['last_name']
user.bio = request.data['bio']
user.email = request.data['email']
user.setPictureFromRest(request.data['picture'])
address = request.data['address']
if address:
address = json.loads(address)
if address:
if len(address) == 5:
user.street = address[0]
user.city = address[1]
user.state = address[2]
user.country = address[3]
user.zip = int(address[4] or 0)
user.save()
return Response({
"user":
UserSerializer(user, context=self.get_serializer_context()).data,
})
def login_status(self, request):
# check login status
data = {'has_logged_in': request.user.is_authenticated}
if request.user.is_authenticated:
data['user'] = UserSerializer(request.user).data
return Response(data)
class TweetSerializer(serializers.ModelSerializer):
user = UserSerializer()
comments_count = serializers.SerializerMethodField()
likes_count = serializers.SerializerMethodField()
has_liked = serializers.SerializerMethodField()
class Meta:
model = Tweet
fields = (
'id',
'user',
'created_at',
'content',
'comments_count',
'likes_count',
'has_liked',
)
def get_likes_count(self, obj):
return obj.like_set.count()
def get_comments_count(self, obj):
return obj.comment_set.count()
def get_has_liked(self, obj):
return LikeService.has_liked(self.context['request'].user, obj)
def signup(self, request):
"""
使用 username, email, password 进行注册
"""
# 不太优雅的写法
# username = request.data.get('username')
# if not username:
# return Response("username required", status=400)
# password = request.data.get('password')
# if not password:
# return Response("password required", status=400)
# if User.objects.filter(username=username).exists():
# return Response("password required", status=400)
serializer = SignupSerializer(data=request.data)
if not serializer.is_valid():
return Response(
{
'success': False,
'message': "Please check input",
'errors': serializer.errors,
},
status=400)
user = serializer.save()
# Create UserProfile object
user.profile
django_login(request, user)
return Response({
'success': True,
'user': UserSerializer(user).data,
},
status=201)
def login(self, request):
"""
默认的 username 是 admin, password 也是 admin
"""
serializer = LoginSerializer(data=request.data)
if not serializer.is_valid():
return Response(
{
"success": False,
"message": "Please check input",
"errors": serializer.errors,
},
status=400)
username = serializer.validated_data['username']
password = serializer.validated_data['password']
user = django_authenticate(username=username, password=password)
if not user or user.is_anonymous:
return Response(
{
"success": False,
"message": "username and password does not match",
},
status=400)
django_login(request, user)
return Response({
"success": True,
"user": UserSerializer(instance=user).data,
})
def login(self, request):
serializer = LoginSerializer(data=request.data)
if not serializer.is_valid():
return Response({
"success": False,
"error": serializer.errors,
},
status=status.HTTP_400_BAD_REQUEST)
# login
username = serializer.validated_data['username']
password = serializer.validated_data['password']
user = django_authenticate(request,
username=username,
password=password)
# username and password not match
if not user or user.is_anonymous:
return Response(
{
"success": False,
"message": "Username and password not match"
},
status=status.HTTP_400_BAD_REQUEST)
# valid username and password
django_login(request, user)
return Response(
{
"success": True,
"user": UserSerializer(instance=user).data,
},
status=status.HTTP_200_OK)
def create_users(self):
"""
Create ordinary Users.
"""
prompt(_(u'Create the users (%d)' % self._total_users))
for item in RandomItemSupplier(self._total_users):
user_serializer = UserSerializer(data=item)
if user_serializer.is_valid():
user_data = user_serializer.data
user_data['is_staff'] = False
user_data['is_active'] = True
user_data['password'] = RandomItemSupplier.USER_PASSWORD
user = self.create_user_by_api(**user_data)
if user:
self._users.append(user)
item['user'] = user.pk
person_serializer = PersonSerializer(data=item)
if person_serializer.is_valid():
person_data = person_serializer.data
person = self.create_person_by_api(**person_data)
if person:
self._persons.append(person)
info(_(u'Done'))
