def check_account(self, request):
"""
检查用户信息
:param request:
:return:
"""
params = request.data
encryptedData = params.get('encryptedData')
iv = params.get('iv')
if not (iv, encryptedData):
raise serializers.ValidationError('encryptedData、iv参数不能为空')
user_info = User.objects.filter(open_id=params.get('user_id')).first()
data = UserSerializer(user_info)
if not data.data:
logger.info('无法通过用户open_id获取用户记录: user_id=%s' % params.get('user_id'))
raise serializers.ValidationError('无法通过用户open_id获取用户记录: user_id=%s' % params.get('user_id'))
# 用户每日登陆获取new币
NewCornCompute.compute_new_corn(user_info.open_id, NewCornType.DAILY_LOGIN.value)
# 录入用户信息到数据库，同时也要注意微信用户可能会更换信息
if user_info.nick_name != params.get('nick_name') or user_info.avatar_url != params.get('avatar_url'):
logger.info('check_account更新用户信息: user_id=%s' % params.get('user_id'))
user_info.nick_name = params.get('nick_name')
user_info.gender = params.get('gender')
user_info.province = params.get('province')
user_info.country = params.get('country')
user_info.city = params.get('city')
user_info.avatar_url = params.get('avatar_url')
user_info.language = params.get('language')
user_info.save()
temp = UserSerializer(user_info).data
logger.info('Update User from Redis')
logger.info(temp)
redis_client.set_instance(user_info.open_id, temp)
return Response()
def post(self, request, *args, **kwargs):
register_step = request.data.pop('register_step', None)
if register_step == 0:
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
request.session['USER'] = request.data
return Response({})
else:
return Response(serializer.errors, status=400)
elif register_step == 1:
otp_code = request.data.pop('otp_code', None)
user_serializer = UserSerializer(data=request.session.get('USER'))
key = request.session.get('OTP_KEY', 0)
if pyotp.TOTP(key).verify(otp_code) and user_serializer.is_valid():
user = user_serializer.save()
SecretKey.objects.create(user=user, key=key)
request.session.flush()
login(request,
user,
backend='django.contrib.auth.backends.ModelBackend')
return Response(UserSerializer(user).data)
else:
return Response({'error': 'OTP doesn\'t match'}, status=400)
else:
return Response(
{'error': 'Unknown register_step %s' % register_step},
status=400)
def post(self, request, format='json'):
user_serializer = UserSerializer(data=request.data)
if user_serializer.is_valid():
user = user_serializer.save()
if user:
serializer = UserSerializer(instance=user)
return Response(user.username, status=status.HTTP_201_CREATED)
return Response(user_serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def get(self, request, pk=None, *args, **kwargs):
if not pk:
users = User.objects()
serializer = UserSerializer(users, many=True)
return Response(serializer.data)
try:
user = User.objects.get(pk=pk)
except:
return Response({}, status=status.HTTP_204_NO_CONTENT)
else:
serializer = UserSerializer(user)
return Response(serializer.data)
class AttendanceSerializer(serializers.ModelSerializer):
# session_id = SabhaSessionSerializer(read_only=True)
user = UserSerializer(read_only=True, fields=('username', ))
last_modified_by = UserSerializer(read_only=True, fields=('username', ))
# To change the key name in response
session_info = GetSabhaSessionSerializer(read_only=True,
source='session_id',
fields=('id', 'sabhatype'))
class Meta:
model = Attendance
fields = ('status', 'user', 'last_modified_by', 'session_info',
'leave_reason')
def post(self, request, format=None):
data = json.loads(request.body)
username = data.get('username', None)
password = data.get('password', None)
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
serialized = UserSerializer(user)
return Response(serialized.data)
else:
return Response(
{
'error': 'Awkward! Your account has been disabled.',
},
status=status.HTTP_401_UNAUTHORIZED)
else:
return Response(
{'error': 'Looks like your username or password is wrong'},
status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs):
user_id = self.request.user.id
filter = request.query_params['filter']
filter_json = json.loads(filter)
customers = User.objects.filter(Q(email__icontains=filter_json['arg'])).exclude(id=user_id).all()
customers_serializer = UserSerializer(customers, many=True)
return Response(customers_serializer.data)
def post(self, request):
""" Create a User """
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class NormalMessageSerializer(serializers.ModelSerializer):
subject = SubjectSerializer(read_only=True)
author = UserSerializer(read_only=True, required=False)
class Meta:
model = NormalMessage
fields = ('id', 'content', 'subject', 'author', 'message_vote')
class CourseGetSerializer(serializers.ModelSerializer):
teacher = UserSerializer()
assignments = AssignmentSerializer(many=True)
notifications = serializers.SerializerMethodField()
students = serializers.PrimaryKeyRelatedField(many=True,
queryset=User.objects.all())
non_approved_students = serializers.PrimaryKeyRelatedField(
many=True, queryset=User.objects.all())
def get_notifications(self, instance):
if self.context['request'].user.is_anonymous:
return []
return [
NewsSerializer(instance=x).data
for x in instance.notifications.filter(
user=self.context['request'].user)
]
class Meta:
model = Course
fields = (
'id',
'teacher',
'name',
'description',
'created',
'modified',
'students',
'image',
'assignments',
'notifications',
'non_approved_students',
)
def my_jwt_response_handler(token, user=None, request=None):
return {
'token': token,
'user': UserSerializer(user, context={
'request': request
}).data
}
def post(self, request, *args, **kwargs):
auth_step = request.data.pop('auth_step', None)
if auth_step == 0:
attempt = request.session.get('AUTH_ATTEMPT', 0)
if attempt < MAX_AUTH_ATTEMPTS:
request.session['AUTH_ATTEMPT'] = attempt + 1
form = AuthenticationForm(data=request.data)
else:
form = AuthenticationFormWithCaptcha(data=request.data)
if form.is_valid():
user = form.get_user()
request.session['USER_ID'] = user.pk
return Response({})
else:
return Response(form.errors, status=400)
elif auth_step == 1:
otp_code = request.data.pop('otp_code', None)
user = User.objects.get(pk=request.session['USER_ID'])
if otp_verify(user, otp_code):
request.session.flush()
login(request,
user,
backend='django.contrib.auth.backends.ModelBackend')
return Response(UserSerializer(user).data)
else:
return Response({'otp': 'OTP doesn\'t match'}, status=400)
else:
return Response({'error': 'Unknown auth_step %s' % auth_step},
status=400)
def custom_jwt_response_handler(token, user=None, request=None):
return {
"token": token,
"user": UserSerializer(user, context={
"request": request
}).data,
}
def patch(self, request, id):
user = User.objects.get(id=id)
serializer = UserSerializer(instance=user, data=request.data, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class PlotSerializer(serializers.ModelSerializer):
author = UserSerializer(read_only=True)
createdAt = serializers.SerializerMethodField(method_name='get_created_at')
description = serializers.CharField(required=False)
class Meta:
model = Plot
fields = (
'author',
'title',
'info',
'lat',
'lng',
'size',
'region',
'habitat_type',
'description',
'createdAt',
'imageURL'
)
def create(self, validated_data):
author = self.context.get('author', None)
plot = Plot.objects.create(author=author, **validated_data)
return plot
def get_created_at(self, instance):
return instance.created_at.isoformat()
def post(self, request, format=None):
data = request.data
username = data.get('username', None)
password = data.get('password', None)
account = authenticate(username=username, password=password)
if account is not None:
if account.is_active:
login(request, account)
serialized = UserSerializer(account)
return Response(serialized.data)
else:
return Response({
'status': 'Unauthorized',
'message': 'This account has been disabled.'
}, status=status.HTTP_401_UNAUTHORIZED)
else:
return Response({
'status': 'Unauthorized',
'message': 'Username/password combination invalid.'
}, status=status.HTTP_401_UNAUTHORIZED)
def put(self, request, pk, format=None):
user = request.user
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
class PostSerializer(serializers.ModelSerializer):
author = UserSerializer(
default=serializers.CurrentUserDefault(), read_only=True)
class Meta:
model = Post
fields = ('id', 'author', 'title', 'link', 'created_at', 'updated_at',
'comment_count', 'upvote_count')
read_only_fields = ('id', 'created_at', 'updated_at',
'comment_count', 'upvote_count')
def to_representation(self, obj):
returnObj = super(PostSerializer, self).to_representation(obj)
is_upvoted_me = False
is_author_me = False
if isinstance(self.context['request'].user, Account):
is_upvoted_me = obj.postupvote_set.filter(
voter=self.context['request'].user).exists()
is_author_me = obj.author == self.context['request'].user
newObj = {
'is_author_me': is_author_me,
'is_upvoted_me': is_upvoted_me
}
returnObj.update(newObj)
return returnObj
def post(self, request):
data = request.data
user = User.objects.filter(username=data['email'])
if user:
return {'success': 0, 'error': 'user already exist', 'status': status.HTTP_409_CONFLICT}
user_ser = UserSerializer(data=data)
if user_ser.is_valid():
user = user_ser.save()
data = {
'activation_code': generate_activation_token(),
'user': user.id
}
# saving activation code to Activation Model through UserActivationSerializer
user_activation_ser = UserActivationSerializer(data=data)
if user_activation_ser.is_valid(raise_exception=True):
token = user_activation_ser.save()
send_user_mail(
template="activation.html",
first_name=user.first_name,
last_name=user.last_name,
subject="Activate Account",
activation_url="http://localhost:8000?activate="+token.activation_code,
user=user
)
return {'success': 1, 'status': status.HTTP_201_CREATED}
def to_representation(self, instance):
self.fields['name'] = UserSerializer(read_only=True)
self.fields['member'] = StudentSerializer(read_only=True)
self.fields['lecturer_adviser'] = LecturerSerializer(read_only=True)
self.fields['company_name'] = LecturerSerializer(read_only=True)
self.fields['intern_topic'] = LecturerSerializer(read_only=True)
return super(InternshipSerializer, self).to_representation(instance)
def post(self, request, *args, **kwargs):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
print(serializer.errors)
return Response({})
class AccountSerializer(serializers.ModelSerializer):
users = UserSerializer(read_only=True, many=True)
class Meta:
model = Account
fields = 'id', 'users', 'name', 'total', 'limit'
def GetDetails(request):
if request.method == 'GET':
usr = CurrentUser(request)
if usr == None:
return Response({"success":True, "loggedin": False}, status=status.HTTP_200_OK)
return Response({"success":True, "loggedin": True, **dict(UserSerializer(usr).data)})
return Response({"success":False, "message": "Make a GET request."}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
try:
data = json.loads(request.body)
member_id = data.get('member_id', None)
password = data.get('password', None)
remember_me = data.get('remember_me', None)
user = authenticate(member_id=member_id, password=password)
if user:
login(request, user)
serialized_data = UserSerializer(user)
if remember_me is None:
request.session.set_expiry(0)
return Response(serialized_data.data)
else:
return Response(
{
'status': 'Not authorized',
'message': 'Invalid Login Details'
},
status=status.HTTP_401_UNAUTHORIZED)
except ValueError:
return Response(
{
'status': 'Invalid Request',
'message': 'Invalid Request Paramaters'
},
status=status.HTTP_401_UNAUTHORIZED)
def post(self, request, format='json'):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
data = {
"email": serializer.data["email"],
"first_name": serializer.data["first_name"],
"last_name": serializer.data["last_name"]
} # Some unique field for reference
secret_key = "GAMEAPPISFUNNY"
algorithm = "HS256" # You can use MD5 or whatever you want
token_code_data = jwt.encode(data, secret_key, algorithm)
url = 'http://192.168.0.103:8080/user_register/confirm/' + token_code_data.decode(
'utf-8')
# # user = serializer.save()
# if user:
# # token = Token.objects.create(user=user)
# # json = serializer.data
# # json['token'] = token.key
# return Response("User Registration Completed but Pending for Verification", status=status.HTTP_201_CREATED)
try:
send_mail('Verificaion link for Game App', url,
'*****@*****.**',
[serializer.data["email"]])
except:
return Response(
"Please try again later after some time/Report here @ [email protected]",
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
return Response(
"User Registration Completed but Pending for Verification",
status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request):
serialized_user = UserSerializer(request.user,
context={'request': request})
return response.Response(serialized_user.data,
status=status.HTTP_200_OK)
class DoctorSerializer(ProfileSerializer):
'''
'''
user = UserSerializer(many=False)
typed = 'doctor'
title = serializers.CharField(required=False,
allow_blank=True,
default=typed,
initial=typed)
def create(self, validated_data):
email = validated_data['email']
if AuthenticationService.is_email_exists(email):
raise serializers.ValidationError(
detail="Email is already exists. Please check again!")
user = AuthenticationService.create_new_user(
validated_data.pop('user'))
profile = Profile(**validated_data)
profile.user = user
profile.save()
return profile
def validate_title(self, data):
if data != self.typed:
raise serializers.ValidationError(
detail="User must have title {}".format(self.typed))
return data
class OrderSerializer(DynamicFieldsModelSerializer):
order_lines = OrderLineSerializer(many=True)
user = UserSerializer(read_only=True)
order_line_delete = serializers.ListField(child=serializers.UUIDField(), write_only=True)
class Meta:
model = Order
fields = ['id', 'order_lines', 'ship_name',
'ship_email', 'ship_phone', 'ship_address',
'ship_city', 'ship_district', 'payment_method',
'delivery_fee', 'sub_total', 'total',
'user', 'created_at', 'updated_at', 'order_line_delete']
read_only_fields = ['sub_total', 'total', 'name']
def create(self, validated_data):
order_lines_data = validated_data.pop('order_lines')
order = Order.objects.create(**validated_data)
for order_line_data in order_lines_data:
OrderLine.objects.create(order=order, **order_line_data)
return order
def update(self, instance, validated_data):
order_line_delete_ids = validated_data.pop('order_line_delete')
order_lines = validated_data.pop('order_lines')
if order_line_delete_ids:
OrderLine.objects.filter(id__in=order_line_delete_ids).delete()
for order_line in order_lines:
if 'id' in order_line:
order_line_id = order_line.pop('id')
OrderLine.objects.filter(id=order_line_id).update(**order_line)
else:
OrderLine.objects.create(order_id=instance.id, **order_line)
return super(OrderSerializer, self).update(instance, validated_data)
class CommentSerializer(serializers.ModelSerializer):
user = UserSerializer()
post = PostSerializer()
class Meta:
model = Comments
fields = '__all__'
def process_request(self, request):
url_path = request.path
if url_path in ignore_auth_urls:
return
logger.info('Auth Url: %s' % url_path)
# ticket = request.COOKIES.get('ticket')
# if not ticket:
# data = request.GET.dict()
# ticket = data.get('ticket')
data = request.GET.dict()
ticket = data.get('ticket')
if not ticket:
return HttpResponse(content=json.dumps(dict(code=401, msg='未登录')),
content_type='application/json')
auth_res = TicketAuthorize.validate_ticket(ticket)
valid_ticket = auth_res['valid_ticket']
if not valid_ticket:
return HttpResponse(content=json.dumps(
dict(code=401, msg='验证失败: %s' % auth_res['err_msg'])),
content_type='application/json')
if not redis_client.get_instance(key=auth_res['user_id']):
logger.info('Get User Info From DataBase')
user = User.objects.filter(open_id=auth_res['user_id']).first()
serializer = UserSerializer(user)
user_info = serializer.data
redis_client.set_instance(auth_res['user_id'], serializer.data)
else:
user_info = redis_client.get_instance(auth_res['user_id'])
logger.info('Get User Info From Redis')
user_info['ticket'] = ticket
request.user_info = user_info
