def init_users(self, request, pk=None): url = request.data['url'] print(url) print(":next") response = urllib.request.urlopen(url) reader = csv.DictReader(response.read().decode('utf-8').splitlines()) header = ["name", "roll_number", "status", "card_no", "image_url"] if request.data['mode'] == 'create': for each in reader: print(each) row = {} for field in header: row[field] = each[field] serializer = UserSerializer(data=row) if serializer.is_valid(): serializer.save() else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) elif request.data['mode'] == 'update': for each in reader: print(each) row = {} user = User.objects.get(pk=each["roll_number"]) for field in header: row[field] = each[field] serializer = UserSerializer(user, data=row) if serializer.is_valid(): serializer.save() else: return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) return Response(data=None, status=status.HTTP_201_CREATED)
def post(self, request): user = request.data.dict() hash_pwd = make_password(user['password']) user['password'] = hash_pwd serializer = UserSerializer(data=user) serializer.is_valid(raise_exception=True) serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED)
def post(self, request, *args, **kwargs): if not request.data: raise ValidationError('You must provide arguments for create.') if not isinstance(request.data, list): raise ValidationError('You must provide a list of objects.') serializer = UserSerializer(data=request.data, many=True) serializer.is_valid(raise_exception=True) serializer.save() return serializer.data
def put(self, request, id, *args, **kwargs): if not request.data: raise ValidationError('You must provide an updated instance.') session = settings.SQLALCHEMY_SESSION() instance = session.query(User).filter(User.id == id).first() if not instance: raise ValidationError('Object does not exist') serializer = UserSerializer(instance, data=request.data, partial=True) serializer.is_valid(raise_exception=True) serializer.save() return serializer.data
def put(self, request, id, *args, **kwargs): if not request.data: raise ValidationError('You must provide an updated instance.') session = settings.SQLALCHEMY_SESSION() instance = session.query(User).filter(User.id == id).first() if not instance: raise ValidationError('Object does not exist') serializer = UserSerializer(instance, data=request.data, partial=True) serializer.is_valid(raise_exception=True) serializer.save() data = serializer.data session.close() return data
def post(self,request,format=None): postData=request.data postData['is_active']=False postData['profile']['validatedcode']= self.get_validationcode() serializer=UserSerializer(data=postData) if serializer.is_valid() : serializer.save() ## send email pending_message="Hello %s,\n\nThank you for your registration.\n Your account is pendinng. We will review and activate in a due course and send you a notification then.\nRegards,\nSite admin\n\n" % (serializer.data['first_name'],) send_mail("Pending account",pending_message,"*****@*****.**",[serializer.data['email']], fail_silently=True) url="http://%s/accounts/validate" % (request.get_host,) pending_message="Hello %s,\n\nA new account as been added. Please reivew and activate it by clicking on the below url:\n%s\n\nSite admin\n\n" % ('Admin',url,) mail_admins("Pending account",pending_message, fail_silently=True) return Response(serializer.data) error =ResponseRes.get_serializer_error(serializer.errors) return Response({ 'status': 'Failed', 'message': 'This account could not be created. Reason:' + error})
def post(self, request, *args, **kwargs): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = User.objects.create_user(username=request.data['username'], email=request.data['email'], password=request.data['password']) user.save() return Response(UserSerializer(user).data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response({"error": serializer.errors}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def put(self, request, user_id): user = self.get_object(user_id) serializer = UserSerializer(instance = user, data = request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response({"error": serializer.errors})
def post(self, request, format=None): """ 회원가입 --- parameters: - username: string (필수) - email: email (필수) - password: string (필수) - department: string - enterYear: integer - github: string """ serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() subject = 'UniDev 인증 메일입니다.' message = render_to_string( 'user_activate.html', { 'user': user, 'domain': get_current_site(request).domain, 'uid': urlsafe_base64_encode(force_bytes( user.pk)).decode('utf-8'), 'token': account_activation_token.make_token(user), }) email = EmailMessage(subject, message, to=[user.email]) email.send() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format='json'): serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() if user: return Response(serializer.data, status=status.HTTP_201_CREATED)
def post(self, req, id): owner_id = checkCredentials(req) if not owner_id: return add_access_headers( HttpResponse( json.dumps({ 'status': 'err', 'msg': 'User NOT logged in!' }), content_type="application/json", )) user = None try: user = User.objects.get(pk=id) except: return add_access_headers( HttpResponse( json.dumps({ 'status': 'err', 'msg': 'User CANNOT be updated!' }), content_type="application/json", )) if user.role != 'admin': return add_access_headers( HttpResponse( json.dumps({ 'status': 'err', 'msg': 'Not sufficient rights for this operation!' }), content_type="application/json", )) data = req.data.copy() data['password'] = user.password serializer = UserSerializer(user, data=data) if not serializer.is_valid(): return add_access_headers( HttpResponse( json.dumps({ 'status': 'err', 'msg': 'User CANNOT be updated!' }), content_type="application/json", )) serializer.save() return add_access_headers( HttpResponse( json.dumps({'status': 'ok'}), content_type="application/json", ))
def post(self, request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response({ 'status': 'successs', 'message': 'user created successfully' }) return Response({'status': 'errors', 'message': serializer.errors})
def post(self, request): secret_key = os.getenv("GOOGLE_RECAPTCHA_SECRET") data = { 'secret': secret_key, 'response': request.data.get('g-recaptcha-response', None) } resp = requests.post('https://www.google.com/recaptcha/api/siteverify', data=data) print(resp.json()) if not resp.json().get('success'): return Response(data={'error': 'ReCAPTCHA not verified.'}, status=status.HTTP_406_NOT_ACCEPTABLE) user_data = {} user_data['email'] = request.data.get("email", None) user_data['username'] = request.data.get("username", None) user_data['platform'] = request.data.get("platform", 0) user_data['password'] = request.data.get("password", None) if len(user_data['password']) < 6: return Response({"Invalid Password"}, status=status.HTTP_400_BAD_REQUEST) serializer = UserSerializer(data=user_data) if serializer.is_valid(): serializer.save() user = User.objects.filter( Q(username__iexact=user_data['username']) & Q(email=user_data['email'])) user = user[0] token = get_token({ "username": user.username, "platform": user.platform, "date_time": str(datetime.datetime.today()) }) user_data['token'] = token del user_data['password'] try: usertoken = UserToken.objects.get(user=user.id) return Response({"message": "User Already Logged in"}, status=status.HTTP_400_BAD_REQUEST) except UserToken.DoesNotExist: UserToken.objects.create(token=token, user=user) return Response( { "message": "User Signed up successfully", "User": user_data }, status=status.HTTP_201_CREATED) else: return Response({"message": serializer.errors}, status=status.HTTP_400_BAD_REQUEST)
def update(self, request, pk=None): try: item = User.objects.get(pk=pk) except User.DoesNotExist: return Response(status=404) serializer = UserSerializer(item, data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data) return Response(serializer.errors, status=400)
def usuario_lista(request): """ Lista (GET) todos los usuarios o crea (POST) un nuevo usuario :param request: :return: """ # LISTA TODOS LOS USUARIOS if request.method == 'GET': try: lista_json = [] lista_users = Usuario.objects.all() for user in lista_users: if user.user.is_active and not user.user.is_staff: user_json = { 'username': user.user.username, 'first_name': user.user.first_name, 'last_name': user.user.last_name, 'email': user.user.email, 'id': user.id, 'balance': user.balance } lista_json.append(user_json) return Response(lista_json) except KeyError: return Response({"message": "Atributos incorrectos"}, status=status.HTTP_400_BAD_REQUEST) # CREA UN USUARIO elif request.method == 'POST': try: data = JSONParser().parse(request) # Verifica que los datos no sean vacios if not data: return Response({"message": "No se enviaron datos"}, status=status.HTTP_400_BAD_REQUEST) # ENCRIPTA EL PASSWORD data['password'] = make_password(data['password']) serializer = UserSerializer(data=data) if serializer.is_valid(): serializer.save() return Response({ 'username': serializer.data['username'], 'first_name': serializer.data['first_name'], 'last_name': serializer.data['last_name'], 'email': serializer.data['email'] }, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) except KeyError: return Response({"message": "Atributos incorrectos"}, status=status.HTTP_400_BAD_REQUEST) except IntegrityError: return Response({"message": "Atributos duplicados"}, status=status.HTTP_400_BAD_REQUEST)
def post(self, request, format="json"): try: serializer = UserSerializer(data=request.data) if serializer.is_valid(raise_exception=True): user = serializer.save() if user: token = Token.objects.create(user=user) response = serializer.data response["token"] = token.key return Response(response, status=status.HTTP_201_CREATED) except IntegrityError as e: raise serializers.ValidationError()
def put(self, request): user = get_object_or_404(User, id=request.user.id) user_serializer = UserSerializer(user, data=request.data, partial=True) if user_serializer.is_valid(): user_serializer.update(user) data = {"success": "successfully updated settings"} else: return Response(user_serializer.errors, status=HTTP_400_BAD_REQUEST) return Response(data)
def User1(request): #for accesing users and registering new users if request.method == "GET": id = request.session['user_id'] user = User.objects.get(id=id) if user is not None: if user.type == "SuperAdmin": users = User.objects.filter(type="Man") | User.objects.filter( type="Admin") elif user.type == "Admin": users = User.objects.filter(type="Man") elif user.type == "Man": serializer = UserSerializer(user) return JsonResponse(serializer.data, safe=False) serializer = UserSerializer(users, many=True) return JsonResponse(serializer.data, safe=False) # return HttpResponse(user.username) return HttpResponse("No such user") if request.method == "POST": id = request.session['user_id'] user = User.objects.get(id=id) if user is not None: data = JSONParser().parse(request) user_type = data["type"] serializer = UserSerializer(data=data) if user.type == "SuperAdmin": if serializer.is_valid(): serializer.save() return redirect('/user1') elif user.type == "Admin": if user_type == "Man": if serializer.is_valid(): serializer.save() return redirect('/user1') return HttpResponse("Forbidden Operation")
def UserList(request): if request.method == "GET": users = User.objects.all() serializer = UserSerializer(users, many=True) return JsonResponse(serializer.data, safe=False) elif request.method == "POST": 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 test_balance_positivo(self): usuario = Usuario() data = { "username": "******", "first_name": "jose", "last_name": "perez", "password": "******", "email": "*****@*****.**", "balance": 1000 } serializer = UserSerializer(usuario, data=data) self.assertEqual(serializer.is_valid(), True)
def post(self, request): """Register new user and create user profile""" serializer = UserSerializer(data=request.data) if serializer.is_valid(): user = serializer.save() profile = Profile.objects.create(user=user, fname=user.first_name, lname=user.last_name) profile.save() location = Location.objects.create(profile=profile) location.save() if user: json = serializer.data return Response(json, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def put(self,request): postData=request.data user = User.objects.get(pk=postData['id']) serializer = UserSerializer(user,data=postData) if serializer.is_valid(): serializer.save() res=ResponseRes.get_serializer_res(serializer,'Profile has been updated successfully') return Response(res) return Response({'status': 'Modify error', 'message':'Profile could not be modified. Reason:' + ResponseRes.get_serializer_error(serializer.errors)}, status=status.HTTP_400_BAD_REQUEST)
def register(request): user_serializer = UserSerializer(data=request.data) if user_serializer.is_valid(): user = user_serializer.save() request.data['user_id'] = user.id else: return Response(user_serializer.errors, status=HTTP_400_BAD_REQUEST) client_serializer = ClientSerializer(data=request.data) data = {} if client_serializer.is_valid(): client = client_serializer.save() data['response'] = 'successfully registered a new client' data['token'] = Token.objects.get(user=client.user).key else: return Response(client_serializer.errors, status=HTTP_400_BAD_REQUEST) return Response(data)
def setup_user(request): try: if request.method == 'POST': data = JSONParser().parse(request) serializer = UserSerializer(data=data) if serializer.is_valid(): serializer.save() inventory = app.models.inventory( user_id=app.models.user.objects.get( id=serializer["id"].value)) inventory.save() return HttpResponse(JSONRenderer().render(serializer.data), status=201) else: return HttpResponse(serializer.errors, status=404) except Exception as e: return HttpResponse(e, status=400)
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: try: validate_password(request.data['password']) except Exception as password_error: error_array = [] 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(): user_serializer.save() return JsonResponse({'Status': True}) else: return JsonResponse({'Status': False, 'Errors': user_serializer.errors})
def signup(request): try: User.objects.get(username=request.data.get("username")) return Response({'msg':"Username taken."}, status=status.HTTP_400_BAD_REQUEST) except User.DoesNotExist: pass usertype = request.data.get("usertype") serializer = UserSerializer(data=request.data) if serializer.is_valid(): user_instance = serializer.save() if usertype != 'seeker' and usertype != 'provider': return Response(status=status.HTTP_400_BAD_REQUEST) user_instance.profile.usertype = usertype user_instance.profile.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, req): data = req.data.copy() if 'password' in data: bytes = bcrypt.hashpw(data['password'].encode(), bcrypt.gensalt()) data['password'] = bytes.decode() serializer = UserSerializer(data=data) if serializer.is_valid(): serializer.save() return add_access_headers( HttpResponse( json.dumps({'status': 'ok'}), content_type="application/json", )) else: return add_access_headers( HttpResponse( json.dumps({'status': 'not_ok'}), content_type="application/json", ))
def signup(request): try: User.objects.get(username=request.data.get("username")) return Response({'msg': "Username taken."}, status=status.HTTP_400_BAD_REQUEST) except User.DoesNotExist: pass usertype = request.data.get("usertype") serializer = UserSerializer(data=request.data) if serializer.is_valid(): user_instance = serializer.save() if usertype != 'seeker' and usertype != 'provider': return Response(status=status.HTTP_400_BAD_REQUEST) user_instance.profile.usertype = usertype user_instance.profile.save() return Response(serializer.data, status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def register(request): if not is_client_known(request): return Response('Forbidden', status=401) serialized = UserSerializer(data=request.data) if serialized.is_valid(): user = User.objects.create_user( username=serialized.validated_data['username'], password=serialized.validated_data['password'], ) user.email = serialized.validated_data['email'] user.save() user.profile = UserProfile() user.profile.save() createMail(user) return get_access_token(user) return Response(serialized._errors, status=400)
def post(self, request): req_data = {} req_data['email'] = request.data.get("email", None) req_data['username'] = request.data.get("username", None) req_data['platform'] = request.data.get("platform", 0) req_data['password'] = request.data.get("password", None) req_data['is_superuser'] = True # Hardcoded the password and email address if (req_data.get('password', None) == os.getenv('ADMIN_PASSWORD') and req_data.get('username', None) == os.getenv('ADMIN_USERNAME') and req_data.get('email', None) == os.getenv('ADMIN_EMAIL_ID')): try: # Checking if Admin already signed up user = User.objects.get(username=req_data['username'], email=req_data['email']) return Response({"message": "Admin already signed Up"}, status=status.HTTP_400_BAD_REQUEST) except User.DoesNotExist: # Creating superuser (Admin) print(req_data) serializer = UserSerializer(data=req_data) if serializer.is_valid(): serializer.save() user = User.objects.get(username=req_data['username'], email=req_data['email']) user.is_superuser = True user.password = req_data['password'] user.save() return Response({"message": "Admin signed up"}, status=status.HTTP_200_OK) else: return Response({"message": "Invalid Data"}, status=status.HTTP_400_BAD_REQUEST) else: return Response({"message": "Invalid Email and Password"}, status=status.HTTP_400_BAD_REQUEST)
def register(request): serializer = UserSerializer(data=request.data) data = {} st = None if serializer.is_valid(): user = serializer.save() st = status.HTTP_201_CREATED request.data['user'] = user.id client = ClientSerializer(data=request.data) if client.is_valid(): client.save() data['response'] = 'succesfully registered a new user' st = status.HTTP_201_CREATED else: data = serializer.errors st = status.HTTP_400_BAD_REQUEST else: data = serializer.errors st = status.HTTP_400_BAD_REQUEST return Response(data, status=st)
def post(self, request): if {'first_name', 'last_name', 'email', 'password', 'company', 'position', 'type'}.issubset(request.data): try: validate_password(request.data['password']) except Exception as password_error: error_array = [] for item in password_error: error_array.append(item) return JsonResponse({'Status': False, 'Errors': {'password': error_array}}) else: request.data._mutable = True 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_signal.delay(user_id=user.id) return JsonResponse({'Status': True}) else: return JsonResponse({'Status': False, 'Errors': user_serializer.errors}) return JsonResponse({'Status': False, 'Errors': 'Не указаны все необходимые аргументы'})
def post(self, request, *args, **kwargs): serializer = UserSerializer(data=request.data) serializer.is_valid(raise_exception=True) serializer.save() return serializer.data
def usuario_datos(request, id_user): """ Obtiene (GET), modifica (PUT) o borra (DELETE) un usuario :param request: :param id_user: el id del usuario que se quiere obtener, borrar o modificar :return: """ if id_user.isdigit(): usuario = get_object_or_404(User, pk=int(id_user)) else: usuario = get_object_or_404(User, username=id_user) usuario = get_object_or_404(Usuario, user_id=usuario.id) # VERIFICA QUE EL USUARIO ESTE ACCEDIENDO A SUS DATOS Y NO A LOS DE OTRO if not request.user.is_staff: if request.user.id != usuario.user_id: return Response({"message": "No tiene permisos para acceder"}, status=status.HTTP_401_UNAUTHORIZED) # OBTIENE UN USUARIO if request.method == 'GET': return Response({ 'username': usuario.user.username, 'first_name': usuario.user.first_name, 'last_name': usuario.user.last_name, 'email': usuario.user.email, 'id': usuario.id, 'balance': usuario.balance }) # ACTUALIZA LOS DATOS DE UN USUARIO VALIDANDO LOS CAMPOS INGRESADOS elif request.method == 'PUT': try: data = JSONParser().parse(request) # ENCRIPTA EL PASSWORD if 'password' in data: data['password'] = make_password(data['password']) serializer = UserSerializer(usuario, data=data) if serializer.is_valid(raise_exception=True): serializer.save() return Response({ 'username': serializer.data['username'], 'first_name': serializer.data['first_name'], 'last_name': serializer.data['last_name'], 'email': serializer.data['email'] }) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST) except KeyError: return Response({"message": "Atributos incorrectos"}, status=status.HTTP_400_BAD_REQUEST) except IntegrityError: return Response({"message": "Atributos duplicados"}, status=status.HTTP_400_BAD_REQUEST) # BORRA UN USUARIO elif request.method == 'DELETE': if usuario.validar_delete(): usuario.user.delete() usuario.delete() return Response({"message": "El usuario ha sido borrado"}, status=status.HTTP_204_NO_CONTENT) return Response({"message": "No puede borrar"}, status=status.HTTP_400_BAD_REQUEST)
def add_users(request): serializer = UserSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response('successfully added', status=status.HTTP_201_CREATED) return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def post(self, request): token = request.headers.get('Authorization', None) if token is None or token == "": return Response({"message": "Authorization credentials missing"}, status=status.HTTP_403_FORBIDDEN) user = get_user(token) if user is None: return Response({"message": "User Already Logged Out"}, status=status.HTTP_403_FORBIDDEN) if user.is_superuser == False: return Response({"message": "Not an Admin"}, status=status.HTTP_403_FORBIDDEN) if 'file' not in request.data: return Response({"message": "File Missing"}, status=status.HTTP_400_BAD_REQUEST) file = request.data['file'] extension = file.name.split('.')[-1] if extension not in ['csv', 'xls', 'xlsx']: return Response({"message": "Invalid File Format"}, status=status.HTTP_400_BAD_REQUEST) content = file.read() records = pyexcel.iget_records(file_type=extension, file_content=content) print( "____________________________________________________________________" ) for record in records: ##### USERNAME ######## username = record.get('username', None) if username == "": print("LOGS: USER -> Username Missing") continue ##### EMAIL ######## email = record.get('email', None) if email == "": email = None ##### ANSWER ######## answer_body = record.get('answer_body', None) if answer_body == "": answer_body = None ##### MARKS ######## evaluated = False marks = record.get('marks', None) if marks == "": marks = 0 evaluated = False else: marks = int(marks) evaluated = True platform = 1 user = User.objects.filter( Q(username__iexact=username) & Q(email=email)) if len(user) != 0: ##### QUESTION ######## daily_challenge = record.get('daily_challenge', None) if daily_challenge == "": print("LOGS: QUESTION -> Question Missing") continue try: question = Question.objects.get(id=daily_challenge) except Question.DoesNotExist: print("LOGS: QUESTION -> Question Not Found") continue user = user[0] answer = { "answer_type": 0, "answer_body": answer_body, "daily_challenge": question.id, "user_id": user.id, "marks": marks, "evaluated": evaluated } else: user_data = { "username": username, "email": email, "platform": platform } user_serializer = UserSerializer(data=user_data) if user_serializer.is_valid(): user_serializer.save() print("LOGS: USER -> New User created username = "******"": print("LOGS: QUESTION -> Question Missing") continue try: question = Question.objects.get(id=daily_challenge) except Question.DoesNotExist: print("LOGS: QUESTION -> Question Not Found") continue answer = { "answer_type": 0, "answer_body": answer_body, "daily_challenge": question.id, "user_id": user.id, "marks": marks, "evaluated": evaluated } else: print("LOGS: USER -> Invalid user username = "******"LOGS: ANSWER -> Answer Already Stored for user " + username) except: serializer = AnswerSerializer(data=answer) if serializer.is_valid(): serializer.save() new_answer = Answer.objects.get( user_id=answer['user_id'], daily_challenge=question.id) new_answer.evaluated = evaluated new_answer.save() print("LOGS: ANSWER -> Answer stored for " + username) else: print("LOGS: ANSWER -> Invalid Answer of " + username) print( "____________________________________________________________________" ) return Response({"message": "Records saved succesfully"}, status=status.HTTP_200_OK)