def login_handle(request, pk):
try:
user = UserInfo.objects.get(pk=pk)
except user.DoesNotExist:
return HttpResponse(status=404)
#
if request.method == 'POST':
serializer = UserSerializer(user)
return JSONResponse(serializer.data)
# 获得指定用户的信息
elif request.method == 'GET':
serializer = UserSerializer(user)
return JSONResponse(serializer.data)
# 修改指定用户的信息（忘记密码）
elif request.method == 'PUT':
data = JSONParser().parse(request)
try:
user = UserInfo.objects.get(pk=pk)
except user.DoesNotExist:
return HttpResponse(status=404)
serializer = UserSerializer(user, data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
# 删除指定用户信息
elif request.method == 'DELETE':
user.delete()
return HttpResponse(status=204)
def user_with_id(id):
pretty = True
if 'X-Requested-With' in request.headers:
pretty = False
print pretty
if request.method == 'GET':
user = User.query.filter_by(id=id).first_or_404()
pv = PageView(page='User')
db.session.add(pv)
db.session.commit()
return Response(
UserSerializer().serialize(user, pretty=pretty),
mimetype='application/json' if not pretty else 'text/html')
elif request.method == 'DELETE':
user = User.query.filter_by(id=id).first_or_404()
pv = PageView(page='User')
db.session.add(pv)
db.session.delete(user)
db.session.commit()
return '', 204
elif request.method == 'PUT':
user = User.query.filter_by(id=id).first_or_404()
user.save(**(request.json))
pv = PageView(page='User')
db.session.add(pv)
db.session.commit()
return Response(
UserSerializer().serialize(user, pretty=pretty),
mimetype='application/json' if not pretty else 'text/html')
def user():
pretty = True
if 'X-Requested-With' in request.headers:
pretty = False
print pretty
if request.method == 'GET':
pv = PageView(page='User')
db.session.add(pv)
db.session.commit()
return Response(
UserSerializer().serialize(User.query.all(),
many=True,
pretty=pretty),
mimetype='application/json' if not pretty else 'text/html')
elif request.method == 'POST':
user = User(**(request.json))
pv = PageView(page='User')
db.session.add(pv)
db.session.add(user)
db.session.commit()
return Response(
UserSerializer().serialize(user, pretty=pretty),
status=201,
mimetype='application/json' if not pretty else 'text/html')
def post(self, request, format=None, sport=None):
try:
email = request.data['email']
existing_user = User.objects.get(email=email)
return Response(error_response(
'User with email %s already exists.' % email),
status=status.HTTP_400_BAD_REQUEST)
except:
pass
sport = int(request.query_params.get('sport', '0'))
user = UserSerializer()
user_fields = [key for key in user.get_fields().keys()]
user_data = {
key: request.data[key]
for key in user_fields if key in request.data
}
user_data['type_id'] = SPORTS[sport][1]
user_serializer = UserSerializer(data=user_data)
# Create base user
if user_serializer.is_valid():
if not 'password' in request.data:
return Response(error_response('Password not provided.'),
status=status.HTTP_400_BAD_REQUEST)
else:
user = user_serializer.save()
user.set_password(request.data['password'])
user.save()
# Create specific user (swimmer, runner...)
if sport == 0:
swimmer = SwimmerSerializer()
swimmer_fields = [key for key in SwimmerSerializer.specific_fields]
swimmer_data = {
key: request.data[key]
for key in swimmer_fields if key in request.data
}
swimmer_data['type'] = user.id
serializer = SwimmerSerializer(data=swimmer_data)
elif sport == 1:
runner = RunnerSerializer()
runner_fields = [key for key in RunnerSerializer.specific_fields]
runner_data = {
key: request.data[key]
for key in runner_fields if key in request.data
}
runner_data['type'] = user.id
serializer = RunnerSerializer(data=runner_data)
if serializer.is_valid():
sport_user = serializer.save()
return Response(success_response(serializer.data),
status=status.HTTP_201_CREATED)
return Response(error_response(serializer.errors),
status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kw):
ip = kw.get('pk')
kw['request'] = request
ip_details_request = IPDetails(ip)
result = DetailsSerializer(ip_details_request)
if not request.session.get('alienvaultid'):
traffic_details_request = TrafficDetails(request, ip)
user = UserSerializer(traffic_details_request)
user_serializer = UserSerializer(data=JSONParser().parse(
BytesIO(JSONRenderer().render(user.data))))
user_serializer.is_valid()
user_serializer.save()
response = Response(result.data, status=status.HTTP_200_OK)
return response
def user_collection(request):
if request.method == 'GET':
users = User.objects.all()
serializer = UserSerializer(users, many=True)
return Response(serializer.data)
if request.method == 'PUT':
serializer = UserSerializer(data=request.data)
if not serializer.is_valid():
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
serializer.save()
return Response(serializer.data)
def put(self, request, pk, format=None):
user = self.get_object(pk)
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)
def user_signup(request):
data = JSONParser().parse(request)
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse(serializer.data, status=201)
return JsonResponse(serializer.errors, status=400)
def get(self, request, pk):
user = get_object_or_404(User, pk=pk)
if request.user.is_superuser or request.user == user:
serializer = UserSerializer(user)
return Response(serializer.data)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
def post(self, request):
serializer = UserSerializer(data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=201)
else:
return Response(serializer.errors, status=400)
def userEdit(request):
try:
print request.data
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
#print "valid"
#print serializer.data
return Response(
{
'status': True,
'data': None,
'message': 'Updated'
},
status=status.HTTP_200_OK)
else:
return Response(
{
'status': False,
'data': None,
'message': serializer.errors
},
status=status.HTTP_400_BAD_REQUEST)
except Exception as e:
return Response({
'status': False,
'data': None,
'message': str(e)
},
status=status.HTTP_400_BAD_REQUEST)
def uploadAvatar(request):
if request.method == 'POST':
username = request.POST.get('username')
headImg = request.FILES.get('file')
try:
user = User.objects.get(username = username)
except User.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
serializer = UserSerializer(user)
if username:
user = User.objects.get(username = username)
if headImg:
user.avatar = headImg
user.save()
return Response(serializer, status=status.HTTP_201_CREATED)
else:
errors = {
'error_code': status.HTTP_400_BAD_REQUEST,
'error': 'AVATAR_IS_INVALID',
'message': ErrorMessage.AVATAR_IS_INVALID,
}
return Response(errors, status=status.HTTP_400_BAD_REQUEST)
else:
errors = {
'error_code': status.HTTP_400_BAD_REQUEST,
'error': 'USERNAME_IS_NULL',
'message': ErrorMessage.USERNAME_IS_NULL,
}
return Response(errors, status=status.HTTP_400_BAD_REQUEST)
def create(self, request):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
kwargs = serializer.validated_data
user_data = User(**kwargs)
print datetime.now(pytz.timezone('America/Phoenix'))
user_data.creationTime = datetime.now(
pytz.timezone('America/Phoenix'))
global condition_url
city_data = City.objects.filter(id=self.request.data['cityId'])
if city_data is not None:
name = city_data[0].name
state = city_data[0].state
request_URL = condition_url + state.replace(
" ", "_") + "/" + name.replace(" ", "_") + ".json"
print request_URL
request_data = requests.get(request_URL)
request_json = json.loads(request_data.content)
user_data.timezone = request_json['current_observation'][
'local_tz_short']
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
user_data.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, pk, format=None):
user = self.get_object(pk)
if user == request.user:
serializer = UserSerializer(user)
return Response(serializer.data)
else:
return Response(status=status.HTTP_400_BAD_REQUEST)
def create(self, request, *args, **kwargs):
"""
"""
app = None
try:
app = Application.objects.get(client_id=self.kwargs['client_id'])
except Application.DoesNotExist:
return Response({
'message': 'Invalid client_id.'
}, status=status.HTTP_400_BAD_REQUEST)
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
user = serializer.create()
application_user = ApplicationUser(application=app,
user=user)
application_user.save()
jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
payload = jwt_payload_handler(user)
token = jwt_encode_handler(payload)
return Response({"token": token}, status=status.HTTP_201_CREATED)
else:
return Response({
'data': serializer.errors,
'message': 'User could not be created with the received data.'
}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
serializer_context = {
'request': Request(request),
}
user_data = {}
user_data['email'] = request.data.pop('email')[0]
user_data['username'] = request.data.pop('username')[0]
user_data['password'] = request.data.pop('password')[0]
user_data['first_name'] = request.data.pop('first_name')[0]
user_seriliazer = UserSerializer(data=user_data)
if user_seriliazer.is_valid(request.data):
user = user_seriliazer.save()
request.data['user'] = user.id
serializer = SBUserSerializer(data=request.data,
context=serializer_context)
if serializer.is_valid():
employee = serializer.save()
if request.data.get('user_type') == 'EMPLOYEE':
EmployeeRole.objects.create(
employee=employee,
department=Department.objects.get(
pk=request.data.get('department')),
role=request.data.get('role'))
return Response(serializer.data,
status=status.HTTP_201_CREATED)
else:
user.delete()
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format=None):
queryset = Logistics_user.objects.all()
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)
def post(self, request):
"""
Creates a new account
:param request:
{
"username": "******",
"first_name": "string",
"last_name": "string",
"password": "******",
"email": "string",
"user_type": integer,
"access_level": integer,
"company_id": integer,
"invite_id": integer
}
:return: {message: string, user: UserSerializer, data: DataSerializer}
"""
data = json.loads(request.body)
user = UserSerializer(data=data)
if user.is_valid():
saved_user = user.save()
try:
userdata = Data.objects.create(
user=saved_user,
user_type=data.get('user_type'),
access_level=1,
company_id=data.get('company_id'))
# if the user is a Client, test if it is the first one of that company
# to change ownership
if data.get('user_type') == Data.CLIENT:
company = Company.objects.get(id=data.get('company_id'))
if company.owner is None:
company.owner = saved_user
company.save()
userdata.access_level = Data.ADMIN
userdata.save()
if data.get('invite_id', None):
invite = Invite.objects.get(id=data.get('invite_id'))
invite.accepted = True
invite.save()
return Response(
{
'message': 'User created successfully',
'user': user.data,
'data': DataSerializer(userdata).data
}, status.HTTP_201_CREATED)
except Exception as e:
saved_user.delete()
return Response({'message': 'User couldnt be created'},
status=status.HTTP_400_BAD_REQUEST)
return Response({'message': 'User could not be created'})
def get(self, request):
users = User.objects.all(
) # Con esto recuperamos todos los usuarios de la api
serializer = UserSerializer(
users, many=True
) # con el many a true significa que se le pasan muchos usuarios
return Response(serializer.data)
def get(self, request, pk):
user = self.get_object(pk)
if request.user.has_perm('umaa.list_all_users') or request.user == user:
serializer = UserSerializer(user, many=False)
return Response(serializer.data)
else:
return Response(UNAUTHORIZED_MSG, status=status.HTTP_401_UNAUTHORIZED)
def post(self, request):
serializer = UserSerializer(data=request.DATA)
if serializer.is_valid(): # los serializer funcionan como los djangoforms, así que hay que validarlo
serializer.save() # guardamos en la base de datos el nuevo usuario
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_serializer_class(self, model=None, depth=0):
self_model = model or self.model
class Meta:
model = self_model
read_only_fields = self.read_only_fields
attrs = {
'Meta': Meta
}
if self.request.method == 'GET':
attrs['user'] = UserSerializer(read_only=True)
for foreign_key_field in (field for field in self_model._meta.fields if isinstance(field, ForeignKey)):
if not foreign_key_field.name in ['user', 'baseformmodel_ptr'] and depth < 1:
attrs[foreign_key_field.name] = self.get_serializer_class(foreign_key_field.rel.to, depth+1)()
if self_model.inlines:
for inline_name in self_model.inlines:
class InlineSerializer(serializers.ModelSerializer):
class Meta:
model = getattr(forms.models, inline_name)
read_only_fields = self.read_only_fields
attrs[inline_name.lower() + '_set'] = InlineSerializer(many=True, read_only=True)
return type(
self_model.__name__ + 'Serializer',
(self.model_serializer_class,),
attrs
)
def account_list_view(request):
users = (User.objects.prefetch_related("groups").order_by(
"-date_joined").filter(is_active=True).all())
if "name" in request.GET or "group" in request.GET:
name, group = request.GET.get("name"), request.GET.get("group")
query = None
if name:
query = Q(first_name__icontains=name) | Q(
last_name__icontains=name)
if group:
group_query = Q(groups__name=group)
query = (query & group_query) if query else group_query
if query:
users = users.filter(query)
context = {
"users": UserSerializer(users, many=True).data,
"create_url": reverse("account-create"),
}
if is_react_api_call(request):
return Response(data=context["users"])
else:
return render_react_page(request, "Accounts", "accounts-list", context)
def put(self, request):
"""
"""
# Si cambia el email puede generar problemas serios, por eso se retorna
# un nuevo token
decoded_token = decode_token(request.META)
serializer = UserSerializer(
MyUser.objects.get(email=decoded_token['email']),
data=request.data,
partial=True)
if serializer.is_valid():
user = serializer.save()
jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
payload = jwt_payload_handler(user)
token = jwt_encode_handler(payload)
return Response({"token": token}, status=status.HTTP_200_OK)
else:
return Response({
'data': serializer.errors,
'message': 'User could not be created with the received data.'
}, status=status.HTTP_400_BAD_REQUEST)
def get(self, request, *args, **kwargs):
git_baseurl = "https://api.github.com/search/users?q="
context = {}
git_baseurl = git_baseurl + (request.GET.get('name')
if request.GET.get('name') else '')
git_baseurl = git_baseurl + ("+type:" + request.GET.get('type')
if request.GET.get('type') else '')
#tin= request.GET['in']
repos = request.GET.get('repos') if request.GET.get('repos') else 0
location = request.GET.get('location') if request.GET.get(
'location') else ''
language = request.GET.get('language') if request.GET.get(
'language') else ''
created = request.GET.get('created') if request.GET.get(
'created') else ''
followers = request.GET.get('followers') if request.GET.get(
'followers') else 0
if repos != 0:
git_baseurl = git_baseurl + "+repos:>" + str(repos)
if location != '':
git_baseurl = git_baseurl + "+location:" + location
if language != '':
git_baseurl = git_baseurl + "+language:" + language
if created != '':
git_baseurl = git_baseurl + "+created:" + created
if followers != 0:
git_baseurl = git_baseurl + "+followers:>" + followers
print git_baseurl
headers = {'Accept': 'application/vnd.github.v3.text-match+json'}
r = requests.get(git_baseurl, headers=headers)
response_users = r.json()['items']
for r_user in response_users:
r_user['repos'] = repos
r_user['location'] = location
r_user['language'] = language
r_user['created'] = created
r_user['followers'] = followers
r_user['name'] = ''
r_user['email'] = ''
for text_match in r_user['text_matches']:
if text_match['property'] == 'name':
r_user['name'] = text_match['fragment']
elif text_match['property'] == 'email':
r_user['email'] = text_match['fragment']
r_user['git_id'] = r_user['id']
serializer = UserSerializer(data=r_user)
try:
gituser = GitUser.objects.get(git_id=r_user['id'])
serializer.update(gituser, r_user)
continue
except:
print("Unexpected error:", sys.exc_info()[0])
print("Unexpected error:", sys.exc_info()[1])
pass
if serializer.is_valid():
serializer.save()
else:
print "data not valid"
return HttpResponse("")
def me_view(request):
'''
API endpoint that gives the current user data
---
serializer: UserSerializer
'''
serializer = UserSerializer(request.user, context={'request': request})
return Response(serializer.data)
def patch(self, request):
"""
Edit requester user's profile
"""
user = request.user
data = request.data
deserializer = UserSerializer(user, data=data, partial=True)
if deserializer.is_valid():
if ('password' in data):
user = request.user
user.set_password(data['password'])
user.save()
deserializer.save()
serializer = UserSerializer(deserializer.instance)
return response.Response(serializer.data, status.HTTP_200_OK)
return response.Response(deserializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def post(self, request, *args, **kwargs):
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def get(self, request):
"""
Get requester user's profile info
"""
user = request.user
context = {"request": request}
serializer = UserSerializer(user, context=context)
return response.Response(serializer.data)
def jwt_response_payload_handler(token, user=None, request=None):
""" JWT response for obtain and refresh """
return {
'token': token,
'user': UserSerializer(user, context={
'request': request
}).data
}
