def put(self, request, pk, format=None):
user = Logistics_user.objects.get(pk=pk)
serializer = UserSerializer(user, data=request.data)#, many=True, context={'request': request})
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self,request, format=None):
data = request.DATA
graph = facebook.GraphAPI(data['token'])
profile = graph.get_object("me")
picture = graph.get_connections("me", "picture")
objUser = {}
objUser['first_name'] = profile['first_name']
objUser['last_name'] = profile['last_name']
objUser['email'] = profile['email']
objUser['username'] = profile['id']
objUser['is_active'] = True
objProfile = {}
objProfile['access_token'] = data['token']
objProfile['profile_picture'] = picture['url']
objProfile['gender'] = profile['gender']
objUser['user_profile'] = objProfile
user = UserSerializer()
serializer = UserSerializer(data=objUser)
try:
userobj = User.objects.get(username=objUser['username'])
return Response(objUser, status=status.HTTP_200_OK)
except User.DoesNotExist:
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, 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 createUser(self, 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 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 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 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 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 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 patch(self, request):
serialized = UserSerializer(data=request.DATA)
if serialized.is_valid():
serialized.save()
return Response(status=status.HTTP_205_RESET_CONTENT)
else:
return Response(serialized.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
serializer = UserSerializer(data=request.DATA) # en lugar request.POST
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 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 put(self, request, id, format=None):
snippet = self.get_object(id=id)
serializer = UserSerializer(snippet, data=request.data)
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
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, format=None):
#Si existe el usuario dar mensaje de error de que ya existe.
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 create_user(request):
data = request.data
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return Response({'message': 'Created'})
return Response(serializer.errors)
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 post(self, request):
serialized = UserSerializer(data=request.data)
if serialized.is_valid():
serialized.save()
Player.objects.create(user_id=serialized.data['id'])
return Response(serialized.data, status=status.HTTP_201_CREATED)
else:
return Response(serialized._errors, status=status.HTTP_400_BAD_REQUEST)
def modifyUserInfo(request):
if request.method == 'POST':
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, *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 post(self, request):
serializer = UserSerializer(data=request.DATA) # en lugar request.POST
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 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 register(request):
if request.method == 'POST':
data = JSONParser().parse(request)
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JsonResponse({'success': True})
else:
return JsonResponse({'success': False})
def put(self, request, pk, format=None):
user = Logistics_user.objects.get(pk=pk[0])
serializer = UserSerializer(
user,
data=request.data) #, many=True, context={'request': request})
if serializer.is_valid():
serializer.save()
return Response(serializer.data)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self,request,pk):
user = get_object_or_404(User,pk=pk)
serializer = UserSerializer(user,data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data,status=status.HTTP_200_OK)
else:
return Response(serializer.errors,status=status.HTTP_400_BAD_REQUEST)
def post(self, request):
# Para crear un usuario
# Hay que pasar request.DATA en vez de request.POST
serializer = UserSerializer(data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
# Algo ha ido mal
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
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 put(self, request, pk):
user = self.get_object(pk)
if request.user.has_perm("umaa.edit_user") or request.user == user:
serializer = UserSerializer(user, data=request.DATA, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
return Response(UNAUTHORIZED_MSG, status=status.HTTP_401_UNAUTHORIZED)
def post(self, request):
# Para crear un usuario
# Hay que pasar request.DATA en vez de request.POST
serializer = UserSerializer(data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
# Algo ha ido mal
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def users(request):
if request.method == 'POST':
data = JSONParser().parse(request)
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data, status=201)
else:
return JSONResponse(serializer.errors, status=400)
return HttpResponse(status=400)
def put(self,request, pk):
user = get_object_or_404(User, pk=pk)
if request.user.is_superuser or request.user == user:
serializer = UserSerializer(user, data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data,status=202)
else:
return Response(serializer.errors,status=400)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
def put(self, request, pk):
user = get_object_or_404(User, pk=pk)
if request.user.is_superuser or request.user == user:
serializer = UserSerializer(user, data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=202)
else:
return Response(serializer.errors, status=400)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
def users(request):
if request.method == 'POST':
data = JSONParser().parse(request)
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data, status=201)
else:
return JSONResponse(serializer.errors, status=400)
return HttpResponse(status=400)
def update(self, request, pk):
user = get_object_or_404(User, pk=pk)
if request.user.is_superuser or request.user == user:
serializer = UserSerializer(user, data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_202_ACCEPTED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
def put(self, request, pk):
user = get_object_or_404(User, pk=pk)
serializer = UserSerializer(user, data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def put(self, request, pk):
user = self.get_object(pk)
if request.user.has_perm('umaa.edit_user') or request.user == user:
serializer = UserSerializer(user, data=request.DATA, partial=True)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_200_OK)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
else:
return Response(UNAUTHORIZED_MSG, status=status.HTTP_401_UNAUTHORIZED)
def post(self, request):
serializer = UserSerializer(data=request.DATA)
if serializer.is_valid():
serializer.save()
user = User.objects.get(username=request.DATA["username"])
token = Token.objects.create(user=user)
headers = {"Authorization": "Token " + token.key}
return Response(headers=headers, status=status.HTTP_201_CREATED)
else:
# we should be doing something here like returning
# a bad status code. The examples show how to do this.
# Stop being lazy.
pass
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):
user = get_object_or_404(User, pk=pk)
if request.user.is_superuser or request.user == user:
serializer = UserSerializer(user, data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data,
status=status.HTTP_202_ACCEPTED)
else:
# Algo ha ido mal
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
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 user_list(request):
if request.method =='GET':
users = User.objects.all()
serializer=UserSerializer(users, many=True)
content = JSONRenderer().render(serializer.data)
return HttpResponse(json.dumps(content), content_type='application/json')
elif request.method =='POST':
serializer = UserSerializer(data=request.data)
if serializer.is_valid():
serializer.validated_data
serializer.save()
content = JSONRenderer().render(serializer.data)
return HttpResponse(json.dumps(content), content_type='application/json')
return HttpResponse(serializer.errors)
def post(self, request, format=None):
username = self.request.DATA.get('username', None)
if username is None:
error_msg = "Need to specify a username."
log.error(error_msg)
return Response(error_msg, status=status.HTTP_400_BAD_REQUEST)
serializer = UserSerializer(data=request.DATA,
context={'request': request})
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 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 user_changes(request, cwid):
try:
user = User.objects.get(cwid=cwid)
except User.DoesNotExist:
return Response(status=status.HTTP_404_NOT_FOUND)
if request.method =='GET':
serializer = UserSerializer(user)
content = JSONRenderer().render(serializer.data)
return HttpResponse(json.dumps(content), content_type='application/json')
elif request.method =='PUT':
serializer = UserSerializer(user, data=request.data)
if serializer.is_valid():
serializer.save()
content = JSONRenderer().render(serializer.data)
return HttpResponse(json.dumps(content), content_type='application/json')
return HttpResponse(serializer.errors)
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 post(self, request, *args, **kwargs):
id = request.POST.get('id', None)
attendence_id = request.POST.get('attendence_id', None)
if id:
try:
userobj = User.objects.get(id=id)
ser = UserSerializer(instance=userobj, data={'attendence_id': attendence_id}, partial=True)
if ser.is_valid():
ser.save()
return redirect('/newuser/manager')
else:
return HttpResponse(ser.errors)
except Exception as why:
return HttpResponse(why)
else:
return HttpResponse('invaild params')
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 register(request):
"""
Register new user.
"""
data = request.data['user'].copy()
user = User.objects.create_user(data['username'], data['username'], data['password'])
user.save()
extended_user = {'first_name':data['first_name'],
'last_name':data['last_name'],
'user':user.id}
serializer = UserSerializer(data=extended_user)
if serializer.is_valid():
serializer.save()
return JSONResponse({'msg':'success', 'user': get_user_data(user)})
return JSONResponse({'msg':serializer.errors})
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 create(self, request):
serializer = UserSerializer(data=request.DATA) # en lugar request.POST
if serializer.is_valid():
new_user = serializer.save()
self.send_welcome_email(new_user)
return Response(serializer.data, status=status.HTTP_201_CREATED)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def snippet_list(request):
"""
List all code snippets, or create a new snippet.
"""
if request.method == 'GET':
snippets = UserInfo.objects.all()
serializer = UserSerializer(snippets, many=True)
return JSONResponse(serializer.data)
elif request.method == 'POST':
data = JSONParser().parse(request)
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data, status=201)
else:
return JSONResponse(serializer.errors, status=400)
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 authenticate_ldap(username, password, token):
connection = ldap.initialize("ldap://ldap.iitb.ac.in")
search_result = connection.search_s(
'dc=iitb,dc=ac,dc=in', ldap.SCOPE_SUBTREE, 'uid=%s' % username,
['uid', 'cn', 'givenName', 'sn', 'mail', 'employeeNumber'])
response_data = {
'error': False,
'error_message': "",
'first_name': "",
'last_name': "",
'email': "",
'employeeNumber': "",
'ldap': "",
'name': "",
'token': "",
}
if len(search_result) < 1 or search_result[0][1]['uid'][0] != username:
response_data['error'] = True
response_data['error_message'] = "Invalid Username/Password"
else:
try:
bind_ds = search_result[0][0]
connection.bind_s(bind_ds, password)
response_data['error'] = False
result_dict = search_result[0][1]
response_data['first_name'] = result_dict['givenName'][0]
response_data['last_name'] = result_dict['sn'][0]
response_data['name'] = result_dict['cn'][0]
response_data['email'] = result_dict['mail'][0]
response_data['ldap'] = result_dict['uid'][0]
response_data['employeeNumber'] = result_dict['employeeNumber'][0]
user_serialized = UserSerializer(data=response_data)
if user_serialized.is_valid():
user = user_serialized.save()
user.backend = "django.contrib.auth.backends.ModelBackend"
response_data['id'] = user.id
if token:
user_token = UserToken(user=user)
user_token.save()
response_data['token'] = user_token.token.hex
return response_data, user
else:
response_data['error'] = True
response_data[
'error_message'] = 'Unable to login. Please contact admin'
except ldap.INVALID_CREDENTIALS:
response_data['error'] = True
response_data['error_message'] = "Invalid Credentials"
except:
response_data['error'] = True
response_data['error_message'] = 'Unable to authenticate'
return response_data, None
def put(self, request, pk):
"""
Actualizacion de un usuario
:param request: objeto request
:param pk: clave primaria del usuario a actualizar
:return: oobjeto response
"""
user = get_object_or_404(User, pk=pk)
if request.user.is_superuser or request.user == user: # Para los permisos del usuario, que los usuarios
# normales no puedan modificar el detalle de otro usuario
serializer = UserSerializer(user, data=request.DATA)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=202)
else:
return Response(serializer.errors, status=400)
else:
return Response(status=status.HTTP_404_NOT_FOUND)
def create_user(request):
"""
:type: HttpRequest
:rtype: JSONResponse
"""
if request.method == 'POST':
data = JSONParser().parse(request)
if all([k in data for k in ['password', 'email', 'name']]):
data['password'] = hash_password(data['password'])
data['access_data_key'] = hash_password(data['password'])
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return JSONResponse(serializer.data)
return JSONResponse(serializer.errors, status=400)
else:
return JSONResponse({'Reason': 'Missing Information or Invalid Input'}, status=400)
return JSONResponse({'Reason': 'Something went wrong'}, status=400)
def user_list(request):
print "In the method : %s " + request.method;
# lists all of the users or creates a new one
if request.method == 'GET':
print "In the GET of user list"
users = User.objects.all()
serializer = UserSerializer(users, many=True)
return HttpResponse(serializer.data)
elif request.method == 'POST':
print "In the POST of user list"
data = JSONParser().parse(request)
serializer = UserSerializer(data=data)
if serializer.is_valid():
serializer.save()
return HttpResponse(serializer.data, status=201)
else:
return HttpResponse(serializer.errors, status=400)
