def create(self, validated_data):
user_data = validated_data.pop('user')
user = UserSerializer.create(UserSerializer(),
validated_data=user_data)
deliver, created = Deliver.objects.update_or_create(
user=user, nidNo=validated_data.pop('nidNo'))
return deliver
def create(self, validated_data):
user_data = validated_data.pop('user')
user = UserSerializer.create(UserSerializer(),
validated_data=user_data)
restaurant, created = Restaurant.objects.update_or_create(
user=user, description=validated_data.pop('description'))
return restaurant
def create(self, validated_data):
user_data = validated_data.pop('user')
user = UserSerializer.create(UserSerializer(),
validated_data=user_data)
customer, created = Customer.objects.update_or_create(user=user)
return customer
def get_user_access_token(google_access_token):
created_at = datetime.today().strftime("%Y-%m-%d %H:%M:%S")
user_info = get_google_user_info(google_access_token)
user_data = init_user_data(user_info, created_at)
user_model = User.objects.create(username=user_data['username'],
email=user_data['email'],
image=user_data['image'])
user_serializer = UserSerializer(user_model, data=user_data)
if user_serializer.is_valid():
user_serializer.create()
point_data = init_user_point(user_info, user_model.id, created_at)
point_model = Point.objects.create(user_id=user_model.id)
point_serializer = PointSerializer(point_model, data=point_data)
if point_serializer.is_valid():
point_serializer.create()
jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
payload = jwt_payload_handler(user_model)
token = jwt_encode_handler(payload)
result = {}
result['access_token'] = token
result['email'] = user_model.email
result['user_name'] = user_model.username
result['image'] = user_model.image
return result
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 register2(self, request, *args):
serializer = UserSerializer(data=self.request.data, context=request)
serializer.is_valid(raise_exception=True)
obj = serializer.user_register2()
data = {
'phone': obj.phone,
'email': obj.email,
'msg': '注册成功',
}
return Response({'code': 200, 'data': data})
def create(self, request):
password = hashlib.sha256(request.data.get('password', None).encode())
user = UserSerializer(data={
'name': request.data.get('name', None),
'email': request.data.get('email', None),
'password': str(password.hexdigest())
})
if user.is_valid(raise_exception=True):
user.save()
return Response(user.data, status=201)
else:
return Response(user.errors, status=400)
def home(request):
if request.method == 'POST':
if 'primary' in request.POST:
user_form = UpdateUserPrimaryForm(request.POST,
instance=request.user)
print('user_form', user_form)
user = user_form.save()
elif 'secondary' in request.POST:
user_form = UpdateUserSecondaryForm(request.POST,
instance=request.user)
user = user_form.save()
else:
name = request.POST.get('name')
ProductData.objects.create(user=request.user, name=name)
return redirect('/home/')
else:
if request.user.is_staff:
supplier_list = User.objects.filter(is_staff=False)
serializer = UserSerializer(supplier_list, many=True)
return render(request, 'admin.html',
{'supplier_list': serializer.data})
else:
product_queryset = ProductData.objects.filter(user=request.user)
product_serializer = ProductSerializer(product_queryset, many=True)
return render(request, 'home.html',
{'product_list': product_serializer.data})
class OfferReadSerializer(serializers.ModelSerializer):
item = ItemSerializer()
tag = TagSerializer(many=True)
is_favourite = serializers.SerializerMethodField()
liked_by = serializers.SerializerMethodField()
owner = UserSerializer(read_only=True, many=False)
gallery = ImageSerializer(many=True)
class Meta:
model = Offer
fields = ['id', 'owner', 'item', 'price', 'tag', 'gender', 'description', 'gallery', 'date',
'shipping_abroad', 'is_favourite',
'liked_by', 'sold']
read_only_fields = ['owner']
def get_is_favourite(self, obj):
if self.context['request'].user.is_authenticated:
is_favourite = Favourite.objects.filter(offer=obj.id, user=self.context['request'].user)
if is_favourite.exists():
return True
return False
def get_liked_by(self, obj):
users = []
is_favourite = Favourite.objects.filter(offer=obj.id).select_related('user')
likes = is_favourite.count()
for fav in is_favourite:
users.append(fav.user.nickname)
data = {
'users': users,
'likes': likes
}
return data
class EventSerializer(serializers.ModelSerializer):
organisation = OrganisationSerializer(read_only=True)
location = EventLocationSerializer()
sponsers = EventSponserSerializer(many=True)
comments = EventCommentSerializer(many=True, read_only=True)
tags = EventTagSerializer(many=True)
attendees = UserSerializer(many=True, read_only=True)
@classmethod
def update(self, instance, validated_data):
validated_data.pop('sponsers', None)
validated_data.pop('tags', None)
for (key, value) in validated_data.items():
if key == 'location':
value = EventLocation.objects.get(id=value)
setattr(instance, key, value)
instance.save()
return instance
# This method is used to retrieve M2M fields value in request since in update() these fields are ignored
def to_internal_value(self, data):
sponsers = data.getlist('sponsers')
tags = data.getlist('tags')
self.instance.sponsers.set(sponsers or [])
self.instance.tags.set(tags or [])
return data
class Meta:
model = Event
fields = ('id', 'title', 'description', 'start_datetime',
'end_datetime', 'organisation', 'cover', 'location',
'sponsers', 'attendees', 'tags', 'comments')
def get(self, request):
code = request.GET.get('code')
url = """https://graph.facebook.com/v2.12/oauth/access_token?client_id={}&redirect_uri={}&client_secret={}&code={}""".format(
FB_CLIENT_ID, FB_REDIRECT_URL, FB_CLIENT_SECRET, code)
data = requests.get(url)
data = data.json()
access_token = data.get('access_token')
user_url = 'https://graph.facebook.com/me?fields=first_name,last_name&access_token={}'.format(
access_token)
userdata = requests.get(user_url)
userdata = userdata.json()
user_id = userdata.get('id')
first_name = userdata.get('first_name')
last_name = userdata.get('last_name')
username = str(user_id)
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = User(username=username,
first_name=first_name,
last_name=last_name).save()
user = User.objects.get(username=username)
userializer = UserSerializer(user)
token = generate_token(email=username,
password=first_name,
user_id=user.id)
user = userializer.data
user['courses'] = []
return Response(status=302,
headers={
'Set-Cookie':
'Authorization={}; Path=/'.format(token),
'Location': '/'
},
data={'user': user})
def post(self, request):
email = request.data.get('email')
password = request.data.get('password')
if email and password:
try:
user = User.objects.get(email=email)
if user and user.check_password(password):
token = generate_token(email=email,
password=password,
user_id=user.id)
userdata = UserSerializer(user).data
userdata['courses'] = list(
user.course_set.values_list('id', flat=True))
return Response(headers={
'Set-Cookie':
'Authorization={}; Path=/'.format(token)
},
data={'user': userdata})
else:
raise AuthenticationFailed
except User.DoesNotExist:
raise NotFound
else:
raise ParseError
class NotificationSerializer(serializers.ModelSerializer):
post = PostSerializer(read_only=True)
other_user = UserSerializer(read_only=True)
class Meta:
model = Notification
fields = ['id','message','seen','notification_type','other_user','post','user','timestamp']
class EventCommentSerializer(serializers.ModelSerializer):
commented_by = UserSerializer()
class Meta:
model = EventComment
fields = ('id', 'comment', 'commented_by', 'comment_datetime')
def get_is_editable(self, obj):
# if the user logged in has made this post then enable the editing option
user = UserSerializer(self.context['request'].user)
if str(obj.user.id) == str(user.data['id']):
return True
return False
class TaskCommentSerializer(serializers.ModelSerializer):
task = serializers.PrimaryKeyRelatedField(read_only=True)
creator = UserSerializer(read_only=True)
class Meta:
model = TaskComment
fields = '__all__'
class ThreadSerializer(serializers.ModelSerializer):
user1 = UserSerializer(many=False, read_only=True)
user2 = UserSerializer(many=False, read_only=True)
last_message = serializers.SerializerMethodField('get_message',
read_only=True)
def get_message(self, instance):
last_message = Message.objects.filter(
thread=instance).order_by('date_send')
if not last_message:
return None
return MessageSerializer(last_message[0]).data
class Meta:
model = Thread
fields = ['id', 'user1', 'user2', 'last_message']
class FollowerSerializer(serializers.HyperlinkedModelSerializer):
user = UserSerializer(read_only=True)
follow_request_sent = serializers.SerializerMethodField('check_Followrequest_sent')
followed_status = serializers.SerializerMethodField('getFollowedStatus')
class Meta:
model = Follower
fields = ['id', 'block_Status', 'user','follow_request_sent','followed_status']
def check_Followrequest_sent(self,obj):
if obj:
user = obj.user
request = self.context.get("request")
if request and hasattr(request, "user"):
instance = Notification.objects.filter(user=user,other_user=request.user,notification_type="follow").first()
if instance:
return True
return False
return None
return None
def getFollowedStatus(self,obj):
if obj:
request = self.context.get("request")
if request and hasattr(request, "user"):
logged_user = request.user
other_user = obj.user
object = Follower.objects.filter(user=logged_user,followed_user=other_user).first()
if object:
return True
return False
return None
def post(self, request):
email = request.data.get('email')
first_name = request.data.get('first_name')
password = request.data.get('password')
if email and password and first_name:
try:
user = User.objects.get(email=email)
raise ValidationError(detail='Email not unique')
except User.DoesNotExist:
user = User(username=email,
email=email,
first_name=first_name,
password=make_password(password)).save()
user = User.objects.get(email=email)
userializer = UserSerializer(user)
token = generate_token(email=email,
password=password,
user_id=user.id)
user = userializer.data
user['courses'] = []
return Response(headers={
'Set-Cookie':
'Authorization={}; Path=/'.format(token)
},
data={'user': user})
else:
raise ParseError
def get(self, request):
code = request.GET.get('code')
url = 'https://oauth.vk.com/access_token?client_id={}&client_secret={}&redirect_uri={}&code={}'.format(
VK_CLIENT_ID, VK_CLIENT_SECRET, REDIRECT_URL, code)
data = requests.get(url)
data = data.json()
access_token = data.get('access_token')
user_id = data.get('user_id')
user_url = 'https://api.vk.com/method/users.get?access_token=4a9be6044a9be6044a9be604434afa87dc44a9b4a9be604101605ecda0a16e0ca46f3c2&user_ids={}&fields=bdate&v=5.73'.format(
user_id)
userdata = requests.get(user_url)
userdata = userdata.json()['response'][0]
first_name = userdata.get('first_name')
last_name = userdata.get('last_name')
username = str(user_id)
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
user = User(username=username,
first_name=first_name,
last_name=last_name).save()
user = User.objects.get(username=username)
userializer = UserSerializer(user)
token = generate_token(email=username,
password=first_name,
user_id=user.id)
user = userializer.data
user['courses'] = []
return Response(status=302,
headers={
'Set-Cookie':
'Authorization={}; Path=/'.format(token),
'Location': '/'
},
data={'user': user})
class TaskSerializer(serializers.ModelSerializer):
creator = UserSerializer(read_only=True)
executor = serializers.PrimaryKeyRelatedField(read_only=True)
class Meta:
model = Task
fields = '__all__'
class DemandaSerializer(serializers.ModelSerializer):
anunciante = UserSerializer()
class Meta:
model = Demanda
fields = ("id", "descricao", "endereco", "contato", "anunciante",
"finalizado")
depth = 1
class OrganisationSerializer(serializers.ModelSerializer):
owner = UserSerializer()
class Meta:
model = Organisation
fields = ('id', 'name', 'is_active', 'owner', 'logo', 'description',
'email', 'contact_number', 'facebook', 'twitter')
class ChatUserSerializer(serializers.ModelSerializer):
other_user = UserSerializer(read_only=True)
class Meta:
model = ChatUser
fields = [
'id', 'user', 'other_user', 'timestamp', 'unseen_message_count'
]
def login(self, request, *args):
"""
用户登录
"""
serializer = UserSerializer(data=self.request.data, context=request)
serializer.is_valid(raise_exception=True)
# 用户登录之后的token
user_obj, token = serializer.user_login()
data = {
'phone': user_obj.phone,
'token': token,
'city': user_obj.city,
'msg': '登录成功'
}
return Response({'code': 200, 'data': data})
def search_supplier(request):
name = request.GET.get('name')
user_queryset = User.objects.filter(
Q(supplier_business_name__icontains=name, is_staff=False)
| Q(username__icontains=name, is_staff=False)
| Q(supplier_address__icontains=name, is_staff=False))
serializer = UserSerializer(user_queryset, many=True)
return render(request, 'search.html', {'supplier_list': serializer.data})
def get_isLiked(self, obj):
user = UserSerializer(self.context['request'].user)
# query in like model where corresponding post and current user is found
like_query = Like.objects.filter(post=obj, user=user.data['id'])
if like_query:
return "Liked"
return ""
class BlogSerializer(serializers.ModelSerializer):
tags = BlogTagSerializer(many=True)
author = UserSerializer(read_only=True)
author_id = serializers.IntegerField(write_only=True)
class Meta:
model = Blog
fields = "__all__"
def get_info(self, token: str) -> str:
"""
:param token:
:return:
"""
payload = self._check_payload(token=token)
user_obj = self._check_user(payload=payload)
user_serializer = UserSerializer(user_obj)
return user_serializer.data
class BlogCommentSerializer(serializers.ModelSerializer):
blog = BlogSerializer(read_only=True)
blog_id = serializers.IntegerField(write_only=True)
author = UserSerializer(read_only=True)
author_id = serializers.IntegerField(write_only=True)
class Meta:
model = BlogComment
fields = "__all__"