class FriendRequestSerializer(serializers.ModelSerializer):
receiver = UserSerializer()
requester = UserSerializer()
class Meta:
model = FriendRequest
fields = ['id', 'requester', 'receiver', 'status', 'created']
class ProjectSerializer(serializers.ModelSerializer):
lead = UserSerializer()
members = UserSerializer(many=True)
class Meta:
model = Project
fields = "__all__"
def manage_cleaner(request):
try:
logger.info('Request to register new cleaner')
request_data = request.data.copy()
serializer = UserSerializer(data=request_data)
if not serializer.is_valid():
errors = dict(serializer.errors)
field = list(errors.keys())[0]
message = "%s - %s" % (field, errors[field][0])
return Response(
{'message': message},
status=status.HTTP_400_BAD_REQUEST
)
instance = serializer.save(user_type=UserType.CLEANER)
return Response(
UserSerializer(instance=instance, remove_fields=['password']).data,
status=status.HTTP_200_OK
)
except Exception as e:
print(str(e))
logger.debug('Exception caught in file {}'.format(__file__), exc_info=True)
return Response(
{'message': _('Something went wrong !')},
status=status.HTTP_500_INTERNAL_SERVER_ERROR
)
def patch(self, request, pk):
obj = self.get_object(pk)
serializer = UserSerializer(obj, data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class CommissionSerializer(serializers.ModelSerializer):
client = UserSerializer()
commissioned_by = UserSerializer()
project = ProjectSerializer()
class Meta:
model = Commission
fields = "__all__"
def create(self, request):
serializer = UserSerializer(data=request.POST)
if serializer.is_valid(raise_exception=True):
user = User.objects.create_user(**serializer.validated_data)
webhook_url = reverse('email-confirm', request=request)
send_activation_url.apply_async(args=(user.username, user.email,
webhook_url))
return Response(ResponseStatuses.SUCCESSFULLY_REGISTERED)
class HelpSerializer(serializers.ModelSerializer):
assigned_to = UserSerializer()
assigned_by = UserSerializer()
created_by = UserSerializer()
class Meta:
model = HelpIssue
fields = "__all__"
class CivilSerializer(serializers.ModelSerializer):
assigned_to = UserSerializer()
assigned_by = UserSerializer()
cleared_by = UserSerializer()
project = ProjectSerializer()
class Meta:
model = Civil
fields = "__all__"
def post(self, request):
da = UserSerializer(data=request.data)
# ktra du lieu gui len co dung cau truc khong
# da.user = request.user
if not da.is_valid():
return Response(da.errors, status=status.HTTP_400_BAD_REQUEST)
else:
da.save()
return Response(da.data, status=status.HTTP_200_OK)
class UserSerializerTestCase(APITestCase):
def setUp(self):
self.serializer = UserSerializer()
def test_user_created(self):
data = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'profile': {
'boxes_permissions': UserProfile.BOXES_PERM_R,
}
}
user = self.serializer.create(data)
self.assertEqual(user.username, data['username'])
self.assertEqual(user.email, data['email'])
self.assertTrue(user.check_password(data['password']))
self.assertEqual(user.profile.boxes_permissions,
data['profile']['boxes_permissions'])
def test_user_updated(self):
user = UserFactory()
data = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'profile': {
'boxes_permissions': UserProfile.BOXES_PERM_R,
}
}
user = self.serializer.update(user, data)
self.assertEqual(user.username, data['username'])
self.assertEqual(user.email, data['email'])
self.assertTrue(user.check_password(data['password']))
self.assertEqual(user.profile.boxes_permissions,
data['profile']['boxes_permissions'])
def test_get_boxes(self):
user1 = UserFactory()
user2 = UserFactory()
b1 = BoxFactory(owner=user1, visibility=Box.PRIVATE)
b2 = BoxFactory(owner=user1, visibility=Box.PUBLIC)
request = APIRequestFactory().get('/url/')
request.user = user2
self.serializer.context['request'] = request
boxes = self.serializer.get_boxes(user1)
self.assertEqual(len(boxes), 1, msg="Private box shouldn't be shown")
self.assertIn(b2.name, boxes[0])
self.assertIn('http://', boxes[0], msg="Should be absolute URL")
def post(self, request):
sms = request.data.pop('sms_code')
redis_cli = get_redis_connection('sms')
sms_code = redis_cli.get(request.data.get('mobile'))
if sms_code.decode() != sms:
return Response({'data': {'success': False, 'message': '验证码错误'}})
serializer = UserSerializer(data=request.data)
serializer.is_valid()
user = serializer.save()
serializer_jwt = JSONWebTokenSerializer(data=request.data)
token = serializer_jwt.validate(request.data).get('token')
data = jwt_response_payload_handler(token, user, request)
return Response(data)
class CommentSerializer(serializers.ModelSerializer):
user = UserSerializer(read_only=True)
class Meta:
model = Comment
exclude = ('material',)
read_only_fields = ('auto_date',)
class CommentSerializer(serializers.ModelSerializer):
uuid = serializers.UUIDField(format='hex', read_only=True)
user = UserSerializer(read_only=True)
post = serializers.UUIDField(format='hex',
read_only=True,
source='post.uuid')
body = serializers.CharField(max_length=500)
date = serializers.DateTimeField(source='created_at', read_only=True)
class Meta:
model = Comment
fields = ('uuid', 'user', 'post', 'body', 'date')
def update(self, instance, validated_data):
instance.body = validated_data['body']
instance.save(update_fields=['body'])
return instance
def save(self, **kwargs):
if self.instance is None:
if 'user' not in kwargs or 'post' not in kwargs:
raise Exception('user/post not defined')
self.instance = Comment.objects.create(
body=self.validated_data['body'],
user=kwargs['user'],
post=kwargs['post'])
else:
self.instance = self.update(self.instance, self.validated_data)
return self.instance
class ProjectFabricationSerializer(serializers.ModelSerializer):
project = ProjectSerializer()
team = UserSerializer()
class Meta:
model = ProjectFabrication
fields = "__all__"
class CommentSerializer(serializers.ModelSerializer):
author = UserSerializer(read_only=True)
post = PostSerializer(read_only=True)
class Meta:
model = Comment
fields = ['id', 'text_content', 'author', 'post']
async def post(self):
async with self.request.app['db'].acquire() as conn:
model = self.get_model()
request_data = await get_json_data(self.request)
serializer = UserCreateSerializer(data=request_data)
await serializer.create_validate()
registration = serializer.validated_data['registration']
if registration.is_completed:
raise ValidationError(
dict(detail='Registration is already completed'))
data = {
'username': registration.username,
'password': registration.password,
'email': registration.email,
'first_name': registration.first_name,
'last_name': registration.last_name,
'role': serializer.validated_data['role']
}
query = self.build_query('create', values=data)
insert = await conn.execute(query)
query = Registration.update().where(
Registration.c.id == registration.id).values(is_completed=True)
await conn.execute(query)
queryset = model.c.id == insert.lastrowid
query = self.build_query('select', queryset=queryset)
result = await conn.execute(query)
serializer = UserSerializer()
data = await serializer.to_json(result)
return web.json_response(data, status=201)
class ActivitySerializer(serializers.ModelSerializer):
uuid = serializers.UUIDField(format='hex', read_only=True)
title = serializers.CharField(max_length=100)
description = serializers.CharField(max_length=500, required=False)
time = serializers.DateTimeField()
duration = serializers.IntegerField(min_value=5, max_value=600)
address = AddressSerializer(required=True, many=False)
activity_type = ActivityTypeSerializer(many=False, required=True)
public = serializers.BooleanField(required=False)
needs_approval = serializers.BooleanField(required=False)
user = UserSerializer(read_only=True)
tags = TagSerializer(many=True, required=False)
is_group = serializers.BooleanField(read_only=True)
formatted_dates = serializers.DateTimeField(format='%d %B %Y, %H:%M',
source='time',
read_only=True)
class Meta:
model = IndividualActivity
fields = (
'uuid',
'title',
'description',
'time',
'duration',
'address',
'activity_type',
'public',
'needs_approval',
'user',
'tags',
'is_group',
'formatted_dates',
'number_of_attendees',
)
def post(self, request, *args, **kwargs):
code = request.data.get("code", None)
if not code:
LOGGER.error(
"Could not authenticate: No authentication code found")
return HttpResponseBadRequest("No authentication code found")
authentication_backend = AuthenticationBackend()
try:
user = authentication_backend.authenticate(request)
except Exception as e:
LOGGER.error("Could not authenticate: {}".format(str(e)))
return HttpResponseBadRequest("Could not authenticate")
try:
refresh = RefreshToken.for_user(user)
except Exception as e:
LOGGER.error("Could not refresh token: {}".format(str(e)))
return HttpResponseBadRequest("Could not refresh token")
serialized_user = UserSerializer(user)
return Response({
"refresh": str(refresh),
"access": str(refresh.access_token),
"user": serialized_user.data,
})
class TaskSerializer(serializers.HyperlinkedModelSerializer):
user = UserSerializer(read_only=True)
class Meta:
model = Task
fields = ('url','title', 'description', 'status', 'created', 'user', 'tags')clear
def update_profile(self, request, *args, **kwargs):
"""
# Update de user profile info
---
request_serializer: UserUpdateSerializer
response_serializer: UserSerializer
parameters_strategy: merge
parameters:
- name: photo
type: file
required: false
"""
serializer = UserUpdateSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = request.user
if "username" in serializer.data:
user.username = serializer.data["username"]
if "first_name" in serializer.data:
user.first_name = serializer.data["first_name"]
if "last_name" in serializer.data:
user.last_name = serializer.data["last_name"]
if "photo" in request.data:
user.photo = request.data["photo"]
user.save()
return Response(UserSerializer(user, many=False).data,
status=status.HTTP_201_CREATED)
def create_js_context(self, request, *args, **kwargs):
# capture the created tag. Might show more info on the first run
created = request.GET.get('created', None)
activity = get_object_or_404(Activity, uuid=kwargs['uuid'])
can_view_activity(activity, request.user, raise_exception=True)
# try getting user reuqest
try:
# user_request = Request.objects.get(user=request.user, is_deleted=False)
user_request = activity.requests.get(user=request.user,
is_deleted=False)
user_request = RequestSerializer(user_request).data
except:
user_request = None
if activity.is_group:
activity = get_object_or_404(GroupActivity, uuid=activity.uuid)
serializer = GroupActivitySerializer(activity)
else:
activity = get_object_or_404(IndividualActivity,
uuid=activity.uuid)
serializer = IndividualActivitySerializer(activity)
user = request.user
user_serializer = UserSerializer(user)
return {
'user': user_serializer.data,
'activity': serializer.data,
'created': created == 'true',
'is_owner': activity.user == user,
'user_request': user_request
}
def create_js_context(self, request, *args, **kwargs):
# Return user data as JSON to the JS view
user = request.user
serializer = UserSerializer(user)
return {'user': serializer.data}
def post(self, request):
user_id = UserSerializer(request.user).data['id']
user = User.objects.get(id=user_id)
user.commission_percentage = int(request.data['percentage'])
user.commission_surcharge = int(request.data['surcharge'])
user.save()
return Response({'status': True})
class VisitSerializer(serializers.ModelSerializer):
authors = UserSerializer(many=True, required=False)
author_ids = serializers.PrimaryKeyRelatedField(
queryset=User.objects.all(),
write_only=True,
source="authors",
many=True,
required=False,
)
def get_authors(self, validated_data):
authors_data = validated_data.pop("authors")
authors = []
for author in authors_data:
if isinstance(author, User):
authors.append(author)
else:
author_email = author.get("email", None)
author, _ = User.objects.get_or_create(email=author_email)
authors.append(author)
return authors
def create(self, validated_data):
authors = self.get_authors(validated_data)
visit = Visit.objects.create(**validated_data)
visit.authors.set(authors)
return visit
class Meta:
model = Visit
fields = "__all__"
class MessageSerializer(serializers.ModelSerializer):
sender = UserSerializer(read_only=True)
dialog = DialogSerializer(read_only=True)
class Meta:
model = Message
fields = ('id', 'sender', 'dialog', 'text', 'is_read', 'created',)
def test_user_fields_content(self):
serializer = UserSerializer(self.user)
data = serializer.data
self.assertEqual(data['first_name'], self.user.first_name)
self.assertEqual(data['last_name'], self.user.last_name)
self.assertEqual(data['phone'], self.user.phone)
def retrieve(self, request):
"""
If provided 'pk' is "me" then return the current user.
"""
payments_count = 0
payments = Payment.objects.filter(user=UserSerializer(request.user).data['id'], is_success=False)
if payments:
payments_count = 0
for payment in payments:
payments_count = check_and_complite_payment(payment, payments_count, User.objects.get(
id=UserSerializer(request.user).data['id']))
payments_count += 1
print(payments_count)
if request.user:
return Response({'user': UserSerializer(request.user).data, 'online_count': get_online_users_count()})
return super(UserView, self).retrieve(request)
class GroupSerializer(serializers.ModelSerializer):
uuid = serializers.UUIDField(format='hex', read_only=True)
title = serializers.CharField(max_length=100, required=False)
description = serializers.CharField(max_length=500,
required=False,
allow_blank=True,
allow_null=True)
public = serializers.BooleanField(required=False)
needs_approval = serializers.BooleanField(required=False)
user = UserSerializer(read_only=True)
class Meta:
model = Group
fields = ('uuid', 'title', 'description', 'public', 'needs_approval',
'user')
def create(self, validated_data):
if 'title' not in validated_data:
raise serializers.ValidationError('Title has to be defined!')
return Group.objects.create(**validated_data)
def save(self, **kwargs):
if self.instance is None:
user = kwargs.get('user', None)
if 'user' not in kwargs:
raise Exception('add user to kwargs')
self.instance = self.create(self.validated_data)
self.instance.user = user
self.instance.save(update_fields=['user'])
else:
self.instance = self.update(self.instance, self.validated_data)
return self.instance
class ProjectBidSerializer(serializers.ModelSerializer):
project = ProjectSerializer()
vendor = UserSerializer()
class Meta:
model = LogisticsBid
fields = "__all__"
async def post(self):
async with self.request.app['db'].acquire() as conn:
data = await get_json_data(self.request)
serializer = self.serializer_class(data=data)
await serializer.create_validate()
queryset = (User.c.username == serializer.validated_data['username']) &\
(User.c.password == serializer.validated_data['password'])
query = self.build_query('select', queryset=queryset)
users = await conn.execute(query)
if users.rowcount == 0:
raise ValidationError(
dict(detail='Invalid username or password'))
serializer = UserSerializer()
user_data = await serializer.to_json(users)
if user_data['blocked']:
raise ValidationError(dict(detail='User is blocked'))
query = Token.select().where(Token.c.user == user_data['id'])
result = await conn.execute(query)
if result.rowcount == 0:
key = generate_token()
query = Token.insert().values(key=key, user=user_data['id'])
await conn.execute(query)
else:
token = await result.fetchone()
key = token.key
resp = dict(token=key)
resp.update(user_data)
return web.json_response(resp)
def membership(self, request):
if request.method == 'GET':
if request.user.is_authenticated:
data = UserSerializer(self.request.user, many=False).data
data['membership_fee'] = MembershipSetting.get_solo().membership_fee
data['pickup_locations'] = PartnerSer(Partner.objects.filter(pickup_location=True), many=True).data
return Response(data)
return Response({'status': 'error', 'detail': 'Not authenticated.'}, 401)
if request.method == 'POST':
user = request.user
if not user.is_authenticated:
return Response({'status': 'error', 'detail': 'Not authenticated.'}, 401)
data = request.data
if user.status == 'Pending Approval':
raise APIException('Your membership request in pending approval.')
if user.status == 'Member':
raise APIException('You are already a member.')
membership_setting = MembershipSetting.get_solo()
if not data.get('full_name'):
raise APIException('Full name is required.')
if not data.get('mobile'):
raise APIException('Mobile number is required.')
if not data.get('pickup_location'):
raise APIException('Pickup Location is required')
user.full_name = data.get('full_name')
user.mobile = data.get('mobile')
user.save()
CardStatus.objects.update_or_create(user=user, season=season(), defaults={'status': 'Awaiting Approval',
'pickup_location_id': data.get(
'pickup_location')})
payment_type = 'Renewal' if user.status == 'Expired' else 'Membership'
payment = Payment(user=user, amount=float(membership_setting.membership_fee), type=payment_type, channel='Android')
if data.get('esewa'):
response = json.loads(data.get('esewa_response'))
if float(response['totalAmount']) < float(payment.amount):
raise APIException('You did not pay the full amount.')
esewa_payment = EsewaPayment(amount=payment.amount, pid=response['productId'],
ref_id=response['transactionDetails']['referenceId'])
if esewa_payment.verify():
payment.save()
esewa_payment.payment = payment
esewa_payment.get_details()
esewa_payment.save()
else:
raise APIException('Payment via eSewa failed!')
elif data.get('receipt'):
receipt_no = data.get('receipt_no')
if not receipt_no:
raise APIException('Receipt number is required.')
elif not receipt_no.isdigit():
raise APIException('Invalid receipt number.')
elif not ReceiptData.objects.filter(active=True, from_no__lte=receipt_no, to_no__gte=receipt_no).exists():
raise APIException('Invalid receipt number.')
elif DirectPayment.objects.filter(receipt_no=receipt_no, payment__verified_by__isnull=False).exists():
raise APIException('Invalid receipt number.')
else:
payment.save()
DirectPayment.objects.create(payment=payment, receipt_no=receipt_no)
elif data.get('deposit'):
if not request.data.get('voucher_image'):
raise APIException('Voucher image is required.')
else:
payment.save()
bd = BankDeposit.objects.create(payment=payment, voucher_image=request.data.get('voucher_image'),
bank=BankAccount.objects.first())
if not bd.voucher_image:
payment.delete()
raise APIException('Could not save voucher image.')
else:
raise APIException('No payment method specified.')
user.status = 'Pending Approval'
user.save()
data = UserSerializer(user, many=False).data
return Response(data)