def setUp(self): neo_config.load_config() neo_config.set_project_variables() neo = NeoAPI(neo_config) self.api = neo.activate_testing() self.user1 = db.session.query(UserModel).filter( UserModel.email == "*****@*****.**").first() if self.user1 is None: self.user1 = UserModel(email="*****@*****.**", password="******", first_name="firstname", last_name="lastname", birthday="1995-12-12") self.user2 = db.session.query(UserModel).filter( UserModel.email == "*****@*****.**").first() if self.user2 is None: self.user2 = UserModel(email="*****@*****.**", password="******", first_name="firstname", last_name="lastname", birthday="1111-11-11") self.circle = Circle(name="Mamie") self.linkCircle = UserToCircle(user=self.user1, circle=self.circle) self.linkCircle2 = UserToCircle(user=self.user2, circle=self.circle) db.session.commit() self.token1 = authenticate_user(self.api, self.user1, "test") self.token2 = authenticate_user(self.api, self.user2, "test") self.tokenAdmin = authenticate_user(self.api, "*****@*****.**", "PapieNeo2019")
def setUp(self): neo_config.load_config() neo_config.set_project_variables() neo = NeoAPI(neo_config) self.api = neo.activate_testing() self.user1 = db.session.query(UserModel).filter(UserModel.email == "*****@*****.**").first() if self.user1 is None: self.user1 = UserModel(email="*****@*****.**", password="******", first_name="firstname", last_name="lastname", birthday="1995-12-12") self.user2 = db.session.query(UserModel).filter(UserModel.email == "*****@*****.**").first() if self.user2 is None: self.user2 = UserModel(email="*****@*****.**", password="******", first_name="firstname", last_name="lastname", birthday="1111-11-11") self.user3 = db.session.query(UserModel).filter(UserModel.email == "*****@*****.**").first() if self.user3 is None: self.user3 = UserModel(email="*****@*****.**", password="******", first_name="firstname", last_name="lastname", birthday="1111-11-11") self.create_circle() self.conv1 = Conversation(name="ConversationInfoTest") self.conv2 = Conversation(name="ConversationInfoTest2") self.conv3 = Conversation(name="ConversationInfoTest2") self.UserToConv1 = UserToConv() self.UserToConv2 = UserToConv() self.UserToConv3 = UserToConv() self.UserToConv4 = UserToConv() self.create_conversation(self.conv1, self.user1, self.user2, self.UserToConv1, self.UserToConv2, self.circle) self.create_conversation(self.conv3, self.user1, self.user2, UserToConv(), UserToConv(), self.circle) self.create_conversation(self.conv2, self.user2, self.user3, self.UserToConv3, self.UserToConv4, self.circle2) self.token1 = authenticate_user(self.api, self.user1, "test") self.token2 = authenticate_user(self.api, self.user2, "test") self.token3 = authenticate_user(self.api, self.user3, "test") self.tokenAdmin = authenticate_user(self.api, "*****@*****.**", "PapieNeo2019")
def post(self): user = user_schema.load(request.get_json(), partial=True) # prevent double account if UserModel.find_by_id(user.id): return {'message': 'Account already exists'}, 401 user.username = user.username.lower() user.ip = request.remote_addr # assign unique id player_id = None while player_id is None: temp = UserModel.get_new_PlayerId() if UserModel.find_by_playerId(temp) is None: player_id = temp # user creation user.playerId = player_id user.save_to_db() # settings creation settings = UserSettingsModel(user_id=user.id) settings.save_to_db() return
def post(cls, userId): json_data = request.get_json() user_data = UserModel.find_by_id(userId) admin_data = UserModel.find_by_id(json_data['admin_id']) user_devices = DeviceModel.find_my_devices(userId) type(user_devices) print(len(user_devices)) if user_data: if len(user_devices) == 0: if admin_data: if admin_data.role == "admin": if user_data.isActivated: user_data.isActivated = False user_data.insert_user() return {"Message": "User is DeActivated"}, 201 return {"Message": "User is Already DeActivated"}, 401 return { "Message": "You dont have an access to deactivate other user" }, 401 return {"Message": "Admin Not Found"}, 401 return { "Message": "User has some devices so you cannot deactivate him" }, 401 return {"Message": "User Not Found"}, 401
def setUp(self): neo_config.load_config() neo_config.set_project_variables() neo = NeoAPI(neo_config) self.api = neo.activate_testing() self.user1 = db.session.query(UserModel).filter( UserModel.email == "*****@*****.**").first() if self.user1 is None: self.user1 = UserModel(email="*****@*****.**", password="******", first_name="firstname", last_name="lastname", birthday="1995-12-12") self.user2 = db.session.query(UserModel).filter( UserModel.email == "*****@*****.**").first() if self.user2 is None: self.user2 = UserModel(email="*****@*****.**", password="******", first_name="firstname", last_name="lastname", birthday="1111-11-11") self.create_circle("INFO1") self.create_circle("INFO2") self.create_circle("INFO3") self.token1 = authenticate_user(self.api, self.user1, "test") self.token2 = authenticate_user(self.api, self.user2, "test") self.tokenAdmin = authenticate_user(self.api, "*****@*****.**", "PapieNeo2019")
def add_update_user(): if not LoginController.athenticate_user(): return redirect(url_for("google.login")) resp = google.get("/oauth2/v2/userinfo") email = resp.json()["email"] message = "User created/updated successfully." form = UserForm() if form.validate_on_submit(): username = form.username.data dept_id = form.dept_id.data login_ip = form.login_ip.data user = UserModel.find_by_username(username) if user: user.dept_id = dept_id user.login_ip = login_ip else: user = UserModel(username, dept_id, login_ip) try: user.save() except: message = "Unable to save/update user" flash(message) return render_template('add_user.html', form=form, email=email)
def reset_post(): email = request.form.get('email') pwd = request.form.get('password') conf_pwd = request.form.get('conf_password') if pwd != conf_pwd: flash("Passwords don't math") return redirect(url_for('auth.reset', email=email)) user = UserModel.get_one(args={'email': email, 'request_reset': True}) if not user: flash("No such a user with email {} found".format(email)) return redirect(url_for('auth.login')) hash_pwd = UserModel.generate_hash(pwd) user.update(args={ 'email': email, 'request_reset': True }, data={ "$set": { 'password': hash_pwd }, '$unset': { 'request_reset': 1, 'reset_code': 1 } }) return redirect(url_for('auth.login'))
def setUp(self): neo_config.load_config() neo_config.set_project_variables() neo = NeoAPI(neo_config) self.api = neo.activate_testing() self.user1 = db.session.query(UserModel).filter( UserModel.email == "*****@*****.**").first() if self.user1 is None: self.user1 = UserModel(email="*****@*****.**", password="******", first_name="firstname", last_name="lastname", birthday="1995-12-12") self.user2 = db.session.query(UserModel).filter( UserModel.email == "*****@*****.**").first() if self.user2 is None: self.user2 = UserModel(email="*****@*****.**", password="******", first_name="firstname", last_name="lastname", birthday="1111-11-11") self.circle1 = Circle(name="TestPaymentCircle") self.link1 = UserToCircle() self.link1.user = self.user1 self.link1.circle = self.circle1 db.session.commit() self.token1 = authenticate_user(self.api, self.user1, "test") self.token2 = authenticate_user(self.api, self.user2, "test")
def put(cls, reqId): json_data = request.get_json() request_data = RequestModel.find_by_id(reqId) if request_data.reqStatus == "pending": device_data = DeviceModel.find_by_id(request_data.deviceId) user_data = UserModel.find_by_id(request_data.userId) req_audit_obj = {"reqId": reqId, "handleBy": json_data["admin_id"]} req_audit_model = RequestAuditModel(**req_audit_obj) admin_data = UserModel.find_by_id(json_data['admin_id']) if request_data and admin_data.role == "admin": request_data.reqStatus = "declined" device_data.status = "available" device_data.assignTo = "0" device_data.releaseDate = None request_data.insert_request() device_data.insert_device() req_audit_model.insert_request_audit() # declined request return {"Message": "Request Declined Successfully"}, 201 return {"Message": "Request Not Found"}, 401 return {"Message": "Request Already Resolve"}, 403
def setUp(self): neo_config.load_config() neo_config.set_project_variables() self.neo = NeoAPI(neo_config) self.api = self.neo.activate_testing() self.client = SocketIOTestClient(self.neo.app, socketio) self.client.disconnect() self.user1 = db.session.query(UserModel).filter(UserModel.email == "*****@*****.**").first() if self.user1 is None: self.user1 = UserModel(email="*****@*****.**", password="******", first_name="firstname", last_name="lastname", birthday="1995-12-12") self.user2 = db.session.query(UserModel).filter(UserModel.email == "*****@*****.**").first() if self.user2 is None: self.user2 = UserModel(email="*****@*****.**", password="******", first_name="firstname", last_name="lastname", birthday="1995-12-12") self.circle = Circle(name="Mamie") self.linkCircle = UserToCircle(user=self.user1, circle=self.circle, privilege="ADMIN") self.conversation = Conversation("test", device_access=True) self.conversation.device_access = True self.conversation.circle = self.circle self.link2 = UserToConversation(user=self.user2, conversation=self.conversation) self.device = Device(name="Papie") self.device.circle = self.circle self.device_password = self.device.get_pre_activation_password() self.device.activate(self.device.key) db.session.commit() self.circle_id = self.circle.id self.conversation_id = self.conversation.id self.token1 = authenticate_user(self.api, self.user1, "test") self.token2 = authenticate_user(self.api, self.user2, "test") self.device_token = authenticate_device(self.api, self.device, self.device_password) self.tokenAdmin = authenticate_user(self.api, "*****@*****.**", "PapieNeo2019")
def post(self): data = UserRegister.parser.parse_args() if UserModel.find_by_username(data['username']): return {"massage": "this username already exist"}, 400 user = UserModel(**data) user.save() return {"massage": "user created successfully"}, 201
def put(cls, deviceId, userId): json_data = request.get_json() device_data = DeviceModel.find_by_id(deviceId) if device_data.status == "blocked" or device_data.status == "allocated": return {"Message": "Device is not available"}, 401 user_data = UserModel.find_by_id(userId) req_obj = {"deviceId": deviceId, "userId": userId} request_model = RequestModel(**req_obj) device_obj = { "deviceId": deviceId, "userId": userId, "allocateBy": json_data["admin_id"] } device_audit_model = DeviceAuditModel(**device_obj) admin_data = UserModel.find_by_id(json_data['admin_id']) if device_data and user_data and admin_data.role == "admin": # if device_data.status == "created" or device_data.status == "available" : if user_data.isActivated: if device_data.isActivated: # device_data.isAvailable = False # if user_data.role == "admin": request_model.reqStatus = "approved" device_data.status = "allocated" device_data.assignTo = user_data.email device_data.releaseDate = json_data["releaseDate"] try: device_data.insert_device() request_model.insert_request() # return {"Message": "DEVICE ASSIGNED"}, 201 except: return {"Message": "INTERNAL SERVER ERROR"}, 401 req_model = RequestModel.get_my_last_request( deviceId, userId) req_audit_obj = { "reqId": req_model.reqId, "handleBy": json_data["admin_id"] } req_audit_model = RequestAuditModel(**req_audit_obj) # try: req_audit_model.insert_request_audit() device_audit_model.insert_device_audit() return {"Message": "DEVICE ASSIGNED"}, 201 # except: # return {"Message": "INTERNAL SERVER ERROR"}, 403 # return {"Message": "DEVICE ALREADY ASSIGNED TO USER"}, 403 return {"Message": "DEVICE IS NOT ACTIVATED TO ASSIGN"}, 400 return {"Message": "USER IS NOT ACTIVATED TO ASSIGN"}, 400 return {"MESSAGE": "INVALID REQUEST"}, 400
def post(self): data = UserRegister.parser.parse_args() if UserModel.find_by_username(data['username']): return {'message': 'username already exists'}, 400 user = UserModel(**data) user.save_to_db() return {'message': 'User created successfully '}, 201
def post(self): data = UserRegister.parser.parse_args() if UserModel.find_by_username(data['username']): return {"message": "User with that username already exists."}, 400 user = UserModel(**data) user.save_to_db() return {"message": "User created successfully."}, 201
def post(self): data = Register.parser.parse_args() reguser = UserModel(data['username'], data['password']) try: UserModel.save_to_db(reguser) return {"messege": "User registered successfully!"} except: return {"messege": "An error occurred registering user!"}
def get(self, _id=None): if _id: user = UserModel.find_by_id(_id) if user: return BaseResponse.ok_response('Successful.', user.json(is_long=True)) return BaseResponse.bad_request_response('User does not exists.', {}) else: users = list( map(lambda x: x.json(is_long=True), UserModel.find_all())) return BaseResponse.ok_response('Successful.', users)
def setUp(self): neo_config.load_config() neo_config.set_project_variables() neo = NeoAPI(neo_config) self.api = neo.activate_testing() self.user1 = db.session.query(UserModel).filter( UserModel.email == "*****@*****.**").first() if self.user1 is None: self.user1 = UserModel(email="*****@*****.**", password="******", first_name="firstname", last_name="lastname", birthday="1995-12-12") self.user2 = db.session.query(UserModel).filter( UserModel.email == "*****@*****.**").first() if self.user2 is None: self.user2 = UserModel(email="*****@*****.**", password="******", first_name="firstname", last_name="lastname", birthday="1111-11-11") self.circle = Circle(name="Mamie") self.circle2 = Circle(name="test") self.linkCircle = UserToCircle(user=self.user1, circle=self.circle, privilege="ADMIN") self.linkCircle2 = UserToCircle(user=self.user2, circle=self.circle) self.conversation = Conversation("test") self.conversation.circle = self.circle self.conversation.device_access = True self.device = Device(name="Papie") self.device2 = Device(name="test") self.device2.circle = self.circle2 self.device2_password = self.device2.get_pre_activation_password() self.device2.activate(self.device2.key) self.device.circle = self.circle self.device_password = self.device.get_pre_activation_password() self.device.activate(self.device.key) self.message = Message(is_user=False) self.message.conversation = self.conversation self.message.device = self.device db.session.commit() self.token1 = authenticate_user(self.api, self.user1, "test") self.token2 = authenticate_user(self.api, self.user2, "test") self.device_token = authenticate_device(self.api, self.device, self.device_password) self.device2_token = authenticate_device(self.api, self.device2, self.device2_password) self.tokenAdmin = authenticate_user(self.api, "*****@*****.**", "PapieNeo2019")
def post(cls): json_data = request.get_json() print(type(json_data)) user = UserModel.find_by_email(json_data['email']) if user: return {"Message": "User with this email is already register"}, 401 # personal_info = { # "username" : json_data["username"], # "password" : json_data["password"], # "email" : json_data["email"], # "role": json_data["role"], # "firstName": json_data["firstName"], # "lastName": json_data["lastName"] # } try: user_data = UserSchema().load(json_data) print(user_data) except ValidationError as err: return err.messages, 401 try: user_model = UserModel(**user_data) if user_model.role == "admin": user_model.isActivated = True user_model.insert_user() else: user_model.insert_user() except: return {"Message": "USER_INSERTION_ERROR"}, 401 return {"Message": "USER_REGISTRATION_SUCCESSFUL"}, 201
def setUp(self): neo_config.load_config() neo_config.set_project_variables() neo = NeoAPI(neo_config) self.api = neo.activate_testing() self.user1 = db.session.query(UserModel).filter( UserModel.email == "*****@*****.**").first() if self.user1 is None: self.user1 = UserModel(email="*****@*****.**", password="******", first_name="firstname", last_name="lastname", birthday="1995-12-12") self.user2 = db.session.query(UserModel).filter( UserModel.email == "*****@*****.**").first() if self.user2 is None: self.user2 = UserModel(email="*****@*****.**", password="******", first_name="firstname", last_name="lastname", birthday="1111-11-11") self.user3 = db.session.query(UserModel).filter( UserModel.email == "*****@*****.**").first() if self.user3 is None: self.user3 = UserModel(email="*****@*****.**", password="******", first_name="firstname", last_name="lastname", birthday="1111-11-11") self.circle = Circle(name="TestConversationinvite") self.link = UserToCircle() self.link.user = self.user1 self.link.circle = self.circle self.link2 = UserToCircle() self.link2.user = self.user2 self.link2.circle = self.circle self.conv = Conversation() self.conv.circle = self.circle self.utc1 = UserToConversation(privilege="ADMIN") self.utc1.user = self.user1 self.utc1.conversation = self.conv self.utc2 = UserToConversation(privilege="STANDARD") self.utc2.user = self.user2 self.utc2.conversation = self.conv db.session.commit() self.token1 = authenticate_user(self.api, self.user1, "test") self.token2 = authenticate_user(self.api, self.user2, "test") self.token3 = authenticate_user(self.api, self.user3, "test")
def delete(cls, user_id): user = UserModel.find_by_id(user_id) if not user: return {"message": "User does not exit"}, 404 else: return user.delete_from_db()
def forget_post(): email = request.form.get('email') user = UserModel.get_one(args={'email': email}) if not user: flash("Please check your login details and try again") return redirect(url_for('auth.login')) reset_code = os.urandom(5).hex() user.update( args={'email': email}, data={"$set": { 'request_reset': True, 'reset_code': reset_code }}) # send reset password email html = render_template("emails/reset-password.html", email=email, server=server, code=reset_code) send_email(subject="Reset Password", html=html, user_email=email) flash( "A reset link has been sent to your email, kindly check and reset your password" ) return redirect(url_for('auth.login'))
def delete(cls): try: user_id = get_jwt_identity() data = user_anime_save_schema.load(request.get_json()) user = UserModel.find_by_username(user_id) anime_id = data['anime_id'] if user: if user.has_user_saved_anime(anime_id): successful = user.remove_anime(anime_id) if successful: return { "message": get_text('user_anime_removing_successful') }, 200 return { "message": get_text('user_anime_removing_error') }, 400 return { "message": get_text('user_anime_not_saved_before') }, 404 return { "message": get_text('user_not_found') }, 404 except ValidationError as error: return {"message": get_text('input_error_generic'), "info": error.messages}, 400 except Exception as ex: print(ex) return {"message": get_text('server_error_generic')}, 500
def get(cls): username = get_jwt_identity() try: user = UserModel.find_by_username(username) if user: saved_animes = user.saved_animes.\ with_entities("anime_info.anime_id", "anime_info.title", "anime_info.poster_uri").\ order_by("title").all() return { **user_min_info_schema.dump(user), "saved_animes": [ { "title": saved_anime[1], "anime_id": str(saved_anime[0]), "poster_uri": saved_anime[2] } for saved_anime in saved_animes ] }, 200 return { "message": get_text('user_not_found') }, 404 except Exception as ex: print(ex) return {"message": get_text('server_error_generic')}, 500
def post(cls): json_data = request.get_json() user = UserModel.find_by_id(json_data["userId"]) device = DeviceModel.find_by_id(json_data["deviceId"]) print(json_data["releaseDate"]) if device.status == "available" or device.status == "created": if user and device: if device.isActivated: if device.status == "created" or device.status == "available": try: req_obj = { "deviceId": json_data["deviceId"], "userId": json_data["userId"] } request_data = request_schema.load(req_obj) except ValidationError as err: return err.messages, 401 try: request_model = RequestModel(**request_data) device.status = "blocked" device.releaseDate = json_data["releaseDate"] request_model.insert_request() device.insert_device() except: return {"Message": "REQUEST INSERT ERROR"}, 401 return {"Message": "REQUEST SUCCESSFULLY ADDED"}, 201 return {"Message": "DEVICE IS NOT AVAILABLE"}, 401 return {"Message": "DEVICE IS NOT ACTIVATED"}, 401 return {"Message": "SOMETHING GETTING WRONG"}, 401 return {"Messgae": "Device is not available to request"}, 401
def reset(email, code): user = UserModel.get_one(args={'email': email, 'request_reset': True}) if user and user.request_reset: if user.reset_code == code: return render_template("reset.html", email=email) flash("Reset password link is expired") return redirect(url_for('auth.login'))
def verify_account(email, code): user = UserModel.get_one(args={"email": email}) if user: _user = user.to_json() if bool(_user.get('verification_code', "")): if user.verification_code == code: user.update(args={"email": email}, data={ '$set': { 'is_authenticated': True, 'is_active': True }, '$unset': { 'verification_code': 1 } }) return redirect(url_for('auth.login')) flash("Oh! wrong verification code!") return redirect(url_for('auth.login')) flash("You're account had been already verified!") return redirect(url_for('auth.login')) flash("No such a user with email {} found!".format(email)) return redirect(url_for('auth.login'))
def get(cls, anime_id): if not valid_uuid4(anime_id): response = {"message": get_text('anime_uuid_error')} return response, 400 anime = AnimeModel.find_by_id(anime_id) username = get_jwt_identity() anime_bookmarked = False if username: # if there is an authenticated user # get the user and check if he saved the anime user = UserModel.find_by_username(username) if user.has_user_saved_anime(anime_id): anime_bookmarked = True if anime: episodes = anime.\ episodes.\ with_entities("episode_id", "episode_number").\ order_by("episode_number").all() anime_data = { **anime_info_schema.dump(anime), "anime_bookmarked": anime_bookmarked, "episodes": episode_schema.dump(episodes) } return anime_data, 200 return { "message": get_text('anime_not_found').format(anime_id=anime_id) }, 404
def delete(self, _id: str): user = UserModel.find_by_id(_id) if user: user.delete_from_db() return {'message': 'Account deleted'}, 200 return {'message': 'Account not found'}, 404
def post(self): data = UserRegister.parser.parse_args() if UserModel.find_by_username(data["username"]): return {"message": "A user with that username already exists"}, 400 user = UserModel(**data) user.save_to_db() # connection = sqlite3.connect("data.db") # cursor = connection.cursor() # query = "INSERT INTO users VALUES (NULL,?,?)" # cursor.execute(query, (data["username"], data["password"])) # connection.commit() # connection.close() return {"message": "User created successfuly."}, 201
def post(self): data = _user_parser.parse_args() if UserModel.find_by_username(data['username']): return {"message": "A user with that username already exists"}, 400 elif len(data['username']) < 4: return { "message": "Username must have more than 3 characters" }, 400 elif len(data['password']) < 8: return { "message": "Password must have more than 7 characters" }, 400 user = UserModel(**data) user.save_to_db() return {"message": "User created successfully."}, 201