def post(self, request):
data = request.data
serializer = UserSerializer(data=data)
if serializer.is_valid():
user = serializer.save()
profile = user.profile
token, created = Token.objects.get_or_create(user=user)
return Response({
'user': {
"id": user.id,
"username": user.username,
"email": user.email,
"first_name": user.first_name,
"last_name": user.last_name,
"last_login": user.last_login,
"gender": profile.gender,
"country": profile.country,
"birthday": profile.birthday
},
'meta': {
'token': token.key
}
})
else:
response = Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
return response
def post(self, request, *args, **kwargs):
# проверяем обязательные аргументы
if {'first_name', 'last_name', 'email', 'password', 'company', 'position'}.issubset(request.data):
errors = {}
# проверяем пароль на сложность
try:
validate_password(request.data['password'])
except Exception as password_error:
error_array = []
# noinspection PyTypeChecker
for item in password_error:
error_array.append(item)
return JsonResponse({'Status': False, 'Errors': {'password': error_array}})
else:
# проверяем данные для уникальности имени пользователя
request.data.update({})
user_serializer = UserSerializer(data=request.data)
if user_serializer.is_valid():
# сохраняем пользователя
user = user_serializer.save()
user.set_password(request.data['password'])
user.save()
new_user_registered.send(sender=self.__class__, user_id=user.id)
return JsonResponse({'Status': True})
else:
return JsonResponse({'Status': False, 'Errors': user_serializer.errors})
return JsonResponse({'Status': False, 'Errors': 'Не указаны все необходимые аргументы'})
def patch(self, request, pk):
user = User.objects.get(pk=pk)
serializer = UserSerializer(user, data=request.data)
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)
def post(self, request, *args, **kwargs):
if not request.user.is_authenticated:
return JsonResponse({'Status': False, 'Error': 'Log in required'}, status=403)
# проверяем обязательные аргументы
if 'password' in request.data:
errors = {}
# проверяем пароль на сложность
try:
validate_password(request.data['password'])
except Exception as password_error:
error_array = []
# noinspection PyTypeChecker
for item in password_error:
error_array.append(item)
return JsonResponse({'Status': False, 'Errors': {'password': error_array}})
else:
request.user.set_password(request.data['password'])
# проверяем остальные данные
user_serializer = UserSerializer(request.user, data=request.data, partial=True)
if user_serializer.is_valid():
print(user_serializer)
user_serializer.save()
return JsonResponse({'Status': True})
else:
return JsonResponse({'Status': False, 'Errors': user_serializer.errors})
def get(self, request):
result = {}
try:
data = request.GET
if 'id' in data.keys():
obj = User.objects.filter(id=data.get('id')).first()
if obj:
row = UserSerializer(obj).data
# 获取关联的角色
related_role_id_list = SysUserRole.objects.filter(user_id=data.get('id'))\
.values_list('role_id', flat=True)
related_roles = SysRole.objects\
.filter(id__in=related_role_id_list, is_active=1, is_delete=0).values('id', 'name')
row['roles'] = related_roles
result['data'] = row
else:
result['data'] = {}
result['msg'] = '获取成功'
result['success'] = True
return Response(result, status.HTTP_200_OK)
else:
page_size = int(data.get('pageSize'))
page_no = int(data.get('pageNo'))
account = data.get('account')
name = data.get('name')
is_active = data.get('isActive')
sort = data.get('sort')
if sort:
sort_list = sort.split(',')
else:
sort_list = ['-id']
start = (page_no - 1) * page_size
end = start + page_size
filters = {'is_delete': 0, 'is_active': 1}
if name:
filters['name__startswith'] = name
if account:
filters['username__startswith'] = account
if is_active:
if is_active == 'true':
is_active = 1
else:
is_active = 0
filters['is_active'] = is_active
rows = User.objects.filter(**filters).order_by(
*sort_list)[start:end]
rows = UserSerializer(rows, many=True).data
total = User.objects.filter(**filters).count()
result['msg'] = '获取成功'
result['success'] = True
result['data'] = {}
result['data']['rows'] = rows
result['data']['total'] = total
return Response(result, status.HTTP_200_OK)
except Exception as e:
result['msg'] = '获取用户信息失败：%s' % e
result['success'] = False
return Response(result, status.HTTP_500_INTERNAL_SERVER_ERROR)
def patch(self, request, pk):
user = User.objects.get(pk=pk)
user_data = request.data['user']
serializer = UserSerializer(data=user_data, instance=user)
if serializer.is_valid():
user = serializer.save()
return Response({'message': 'Success'})
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = User.objects.all().filter(userName=request.data["userName"])
if User.objects.filter(userName=request.data["userName"]).exists():
return Response({"error": "Username already taken"})
else:
serializer.save()
return Response({"success": serializer.data})
return Response(serializer.errors, status=status_HTTP_404_BAD_REQUEST)
def get(self, request):
params = request.query_params.get('userName', None)
# Get one user if there is a userName parameter
if params is not None:
user = User.objects.get(userName=params)
serializer = UserSerializer(user)
return Response(serializer.data)
# Get all if no parameters
else:
users = User.objects.all()
serializer = UserSerializer(users, many=True)
return Response(serializer.data)
def get(self, request, **kwargs):
projects = Project.objects.all()
group_memberships = DeveloperGroupMembership.objects.all()
users = User.objects.all()
cards = Card.objects.all()
projects_data = []
for project in projects:
allowed_roles_query = group_memberships.filter(
developer_group_id=project.developer_group_id.id)
group_data = DeveloperGroupSerializer(
project.developer_group_id).data
project_data = ProjectSerializer(project).data
project_cards = cards.filter(project_id=project.id)
print(project_data)
if not project_cards:
project_data["card_active"] = False
else:
project_data["card_active"] = True
project_data["group_data"] = group_data
user_roles_dict = []
for z in allowed_roles_query:
user_roles = get_user_group_roles(z.id)
user_details = users.filter(id=z.user_id.id)[0]
user_data = UserSerializer(user_details).data
user_data["allowed_group_roles"] = user_roles
user_data["group_active"] = z.active
user_roles_dict.append(user_data)
group_data["users"] = user_roles_dict
projects_data.append(project_data)
return Response(projects_data, status=status.HTTP_202_ACCEPTED)
def check_user_auth(request):
profile_model = None
if(request.user.is_authenticated):
user = User.objects.get(username=request.user.username)
if (user.is_superuser):
return Response(UserSerializer(user).data)
try:
print(user)
profile_model =ServiceProvider.objects.filter(user=user)
if profile_model.count()!=0:
data = ServiceProviderSerializer(profile_model[0]).data
data['user_type'] = 'provider'
return Response(data)
except:
print('service provider rel not found')
try:
profile_model = Customer.objects.filter(user=user)
print(profile_model)
if profile_model.count()!=0:
customer_serializer = CustomerSerializer(profile_model[0])
data = customer_serializer.data
data['user_type'] = 'customer'
return Response(data)
except:
print('customer rel not found')
response = {'isAuthenticated':request.user.is_authenticated, 'user':request.user.username}
return Response(response)
else:
# return Response(json.dumps({'data':'user not found'}))
response = {'message':'User not authenticated'}
return Response(response)
def jwt_response_handler(token, user=None, request=None):
return {
'token': token,
'user': UserSerializer(user, context={
'request': request
}).data,
}
def get(self, request):
try:
other_users = User.objects.exclude(id=request.user.id)
serializer = UserSerializer(other_users, many=True)
return Response(serializer.data)
except:
return Response([])
def put(self, request, *args, **kwargs):
# Проверка авторизован ли пользователь
if not request.user.is_authenticated:
return JsonResponse({
'Status': False,
'Errors': 'Пользователь не авторизован'
})
# Изменение данных
serializer = UserSerializer(request.user,
data=request.data,
partial=True)
if serializer.is_valid():
serializer.save()
return JsonResponse({'Status': True, 'Info': serializer.data})
else:
return JsonResponse({'Status': False, 'Errors': serializer.errors})
def check(request):
if request.user.is_authenticated:
return Response({
'token': Token.objects.get(user=request.user).key,
'user_info': UserSerializer(request.user).data,
})
return Response({}, status=status.HTTP_403_FORBIDDEN)
def get_user(self, request, *args, **kwargs):
"""
Retrieve user data
Method to get details from logged user
"""
user = request.user
return HttpResponse(JSONRenderer().render(UserSerializer(user).data),
content_type='application/json')
def get(self, request, *args, **kwargs):
# Проверка авторизован ли пользователь
if not request.user.is_authenticated:
return JsonResponse({
'Status': False,
'Errors': 'Пользователь не авторизован'
})
serializer = UserSerializer(request.user)
return JsonResponse({'Status': True, 'Info': serializer.data})
def get(self, request, *args, **kwargs):
if not request.user.is_authenticated:
return JsonResponse({
'Status': False,
'Error': 'Log in required'
},
status=403)
serializer = UserSerializer(request.user)
return Response(serializer.data)
def post(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = serializer.validated_data
return Response({
"user":
UserSerializer(user, context=self.get_serializer_context()).data,
"token":
AuthToken.objects.create(user)
})
def put(request):
""" change password """
data = request.data
if 'token' in data:
token = data['token']
msg, sta = use_token(token, data['password'])
return Response(msg, sta)
user = request.user
user.set_password(data['password'])
user.save()
return Response(UserSerializer(user).data, status.HTTP_200_OK)
def create_user(request):
validated_data=JSONParser().parse(request)
if(validated_data['password']!=validated_data['password2']):
return JsonResponse("Passwords donot match",safe=False)
elif(User.objects.filter(email=validated_data['email']).exists()):
return JsonResponse("There exists an account with this email",safe=False)
elif(User.objects.filter(username=validated_data['username']).exists()):
return JsonResponse("There exists an account with this username",safe=False)
else:
try:
new_data={}
new_data['username']=validated_data['username']
new_data['password']=validated_data['password']
new_data['email']=validated_data['email']
except:
return JsonResponse("failed",safe=False)
user_serializer=UserSerializer(data=new_data)
if user_serializer.is_valid():
user_serializer.save()
return JsonResponse("success",safe=False)
return JsonResponse("Invalid credentials",safe=False)
def RegisterAPI(req):
if req.method == 'GET':
return HttpResponse(status=201) # trial
if req.method == 'POST':
serializer = UserSerializer(data=req)
print(serializer.is_valid())
if serializer.is_valid():
print(serializer)
"""
username = req.POST.get("username")
password = req.POST.get("password")
email = req.POST.get("email")
first_name = req.POST.get("first_name")
last_name = req.POST.get("last_name")
if User.objects.all().filter(username = username) is None:
return HttpResponse(status = 403)
NewUser = User.objects.create_user(username = username, password = password, email = email, first_name = first_name, last_name = last_name)
NewUser.save()
# user_profile = UserProfile(user = NewUser)
# user_profile.save()
"""
return HttpResponse(status=200)
def put(self, request, *args, **kwargs):
try:
user = User.objects.get(pk=kwargs["pk"])
except User.DoesNotExist:
return HttpResponse(status=404)
data = JSONParser().parse(request)
# Set to existing hash if password is null.
if data["password"] is None:
data["password"] = getattr(user, "password")
serializer = UserSerializer(user, data=data)
success_status=False
if serializer.is_valid():
success_status=True
serializer.save()
else:
print(serializer.errors)
if "roles" in data:
user_id = serializer.data["id"]
allowed_roles = AllowedRole.objects.filter(user_id=user_id)
for role in data["roles"]:
if role not in list(allowed_roles.values_list('role_id', flat=True)):
user = User.objects.get(pk=user_id)
roles = Role.objects.get(pk=role)
AllowedRole.objects.create(user_id=user, role_id=roles)
for i in allowed_roles:
if i.role_id.id not in data["roles"]:
i.delete()
if success_status:
return JsonResponse(serializer.data, status=status.HTTP_200_OK)
return JsonResponse(serializer.errors, status=status.HTTP_406_NOT_ACCEPTABLE)
def post(self, request, format=None):
result = {}
try:
data = request.data
account = data.get('account')
email = data.get('email')
mobile = data.get('mobile')
password = data.get('password')
# 创建者id
if request.user.id is None:
data['creater_id'] = data.get("creater_id")
else:
data['creater_id'] = request.user.id
if not account:
data['account'] = mobile
if 'name' not in data.keys() or data.get('name') == '':
data['name'] = account
data['updater_id'] = data['creater_id']
data['is_delete'] = False
data['password'] = make_password(password)
users = User.objects.filter(username=account, is_delete=0)
if users.exists():
result['msg'] = '新增失败：用户名已存在'
result['success'] = False
return Response(result, status.HTTP_400_BAD_REQUEST)
elif User.objects.filter(email=email, is_delete=0).exists():
result['msg'] = '新增失败：邮箱已存在'
result['success'] = False
return Response(result, status.HTTP_400_BAD_REQUEST)
elif User.objects.filter(mobile=mobile, is_delete=0).exists():
result['msg'] = '新增失败：手机号已存在'
result['success'] = False
return Response(result, status.HTTP_400_BAD_REQUEST)
try:
serializer = UserSerializer(data=data)
serializer.is_valid(raise_exception=True)
serializer.save()
except Exception as e:
result['msg'] = '新增失败：%s' % e
result['success'] = False
return Response(result, status.HTTP_400_BAD_REQUEST)
result['msg'] = '新增成功'
result['success'] = True
result['data'] = serializer.data
return Response(result, status.HTTP_200_OK)
except Exception as e:
result['msg'] = '%s' % e
result['success'] = False
return Response(result, status.HTTP_500_INTERNAL_SERVER_ERROR)
def post(self, request, **kwargs):
data = JSONParser().parse(request)
print(data)
serializer = UserSerializer(data=data)
success_status=False
if serializer.is_valid():
success_status=True
serializer.save()
else:
pass
if "roles" in data:
user_id = serializer.data["id"]
for role_id in data["roles"]:
user = User.objects.get(pk=user_id)
role = Role.objects.get(pk=role_id)
AllowedRole.objects.create(user_id=user, role_id=role)
if success_status:
return Response(serializer.data, status=status.HTTP_201_CREATED)
return JsonResponse(serializer.errors, status=status.HTTP_406_NOT_ACCEPTABLE)
def login(request):
username = request.data['username']
password = request.data['password']
user = authenticate(username=username, password=password)
if user is None:
return Response({}, status=status.HTTP_403_FORBIDDEN)
token = Token.objects.get(user=user)
return Response({
'token': token.key,
'user_info': UserSerializer(user).data
})
def get(self, request, format=None):
result = {}
try:
user = request.user
if user.id:
result['data'] = UserSerializer(user).data
else:
result['data'] = {}
result['msg'] = '获取成功'
result['success'] = True
return Response(result, status.HTTP_200_OK)
except Exception as e:
result['msg'] = '用户当前用户信息失败：%s' % e
result['success'] = False
return Response(result, status.HTTP_500_INTERNAL_SERVER_ERROR)
def register(request):
username = request.data['username']
password = request.data['password']
email = request.data['email']
if User.objects.filter(Q(email=email) | Q(username=username)).exists():
return Response({}, status=status.HTTP_403_FORBIDDEN)
user = User.objects.create_user(username, email=email, password=password)
token = Token.objects.create(user=user)
CustomUserInformation.objects.create(user=user)
return Response({
'token': token.key,
'user_info': UserSerializer(user).data
})
def get(self, request):
result = {}
try:
data = request.GET
obj = User.objects.filter(id=data.get('user_id')).first()
if obj:
result['data'] = UserSerializer(obj).data
else:
result['data'] = {}
result['msg'] = '获取成功'
result['success'] = True
return Response(result, status.HTTP_200_OK)
except Exception as e:
result['msg'] = '获取指定用户信息失败：%s' % e
result['success'] = False
return Response(result, status.HTTP_500_INTERNAL_SERVER_ERROR)
def get(self, request, **kwargs):
roles = Role.objects.all()
allowed_roles = AllowedRole.objects.all()
users = User.objects.all().filter(is_superuser=False).order_by("surname")
user_roles = []
for user in users:
roles_list = []
allowed_roles_query = allowed_roles.filter(user_id=user.id)
for query in allowed_roles_query:
roles_query = roles.filter(id=query.role_id.id)
roles_list.append(roles_query[0].title)
user_allowed_roles = UserSerializer(user).data
user_allowed_roles["roles"] = roles_list
user_roles.append(user_allowed_roles)
return Response(user_roles, status=status.HTTP_202_ACCEPTED)
def post(self, request, format=None):
result = {}
try:
data = request.data
account = data.get('account')
email = data.get('email')
mobile = data.get('mobile')
job_number = data.get('job_number')
data['creater_id'] = request.user.id
data['updater_id'] = data['creater_id']
data['is_delete'] = False
data['password'] = make_password('123456')
users = User.objects.filter(username=account, is_delete=0)
if users.exists():
result['msg'] = '新增失败：用户帐号已存在'
result['success'] = False
return Response(result, status.HTTP_200_OK)
elif User.objects.filter(email=email, is_delete=0).exists():
result['msg'] = '新增失败：邮箱已存在'
result['success'] = False
return Response(result, status.HTTP_200_OK)
elif User.objects.filter(mobile=mobile, is_delete=0).exists():
result['msg'] = '新增失败：手机号已存在'
result['success'] = False
return Response(result, status.HTTP_200_OK)
elif User.objects.filter(job_number=job_number,
is_delete=0).exists():
result['msg'] = '新增失败：工号已存在'
result['success'] = False
return Response(result, status.HTTP_200_OK)
try:
serializer = UserSerializer(data=data)
serializer.is_valid(raise_exception=True)
serializer.save()
except Exception as e:
result['msg'] = '新增失败：%s' % e
result['success'] = False
return Response(result, status.HTTP_400_BAD_REQUEST)
result_data = serializer.data
result_data['roles'] = []
result_data['groups'] = []
result['msg'] = '新增成功'
result['success'] = True
result['data'] = result_data
return Response(result, status.HTTP_200_OK)
except Exception as e:
result['msg'] = '%s' % e
result['success'] = False
return Response(result, status.HTTP_500_INTERNAL_SERVER_ERROR)
