def setUp(self) -> None: # get connection, 2 users, 2 polls (named/unnamed), 4 votes, third user for testing the logIn self.connection = MongoDB() self.user: User = User("mavroudo", "*****@*****.**", "1234") self.user2: User = User("charis", "*****@*****.**", "12345") self.user3: User = User("Stef", "*****@*****.**", "asdf") # user: UserWrapper = self.connection.userDB.deleteUser(self.user.mail) # user2: UserWrapper = self.connection.userDB.deleteUser(self.user2.mail) userWrapper: UserWrapper = self.connection.userDB.createNewUser(self.user.name, self.user.mail, self.user.password) self.assertIsNotNone(userWrapper.object) self.assertIsNotNone(userWrapper.object.session_id) self.session_id = userWrapper.object.session_id userWrapper2: UserWrapper = self.connection.userDB.createNewUser(self.user2.name, self.user2.mail, self.user2.password) self.assertIsNotNone(userWrapper2.object) self.assertIsNotNone(userWrapper2.object.session_id) self.session_id2 = userWrapper.object.session_id # get user id from session_id (user, self.user_id) = self.connection.userDB.getUserWithSessionId(self.session_id) self.assertIsNotNone(user) self.assertNotEqual(self.user_id, "") (user2, self.user_id2) = self.connection.userDB.getUserWithSessionId(self.session_id2) self.assertIsNotNone(user2) self.assertNotEqual(self.user_id2, "") # add polls self.poll: Poll = Poll("how cool are we?", ["A lot", "A lot but second", "same as 2"], named=True, unique=True, creator_user_id=self.user_id) pollWrapper: PollWrapper = self.connection.pollsDB.createPoll(self.poll.question, self.poll.options, self.poll.named, self.poll.unique, self.user_id) self.assertTrue(pollWrapper.operationDone) self.assertIsNotNone(pollWrapper.object) self.poll_id = pollWrapper.pollId self.poll2_noNamed: Poll = Poll("how cool are we?", ["A lot", "A lot but second", "same as 2"], named=False, unique=True, creator_user_id=self.user_id) pollWrapper2: PollWrapper = self.connection.pollsDB.createPoll(self.poll2_noNamed.question, self.poll2_noNamed.options, self.poll2_noNamed.named, self.poll2_noNamed.unique, self.user_id) self.assertTrue(pollWrapper2.operationDone) self.assertIsNotNone(pollWrapper2.object) self.poll_id2 = pollWrapper2.pollId # add 2 votes for each voteWrapper: VotesWrapper = self.connection.votesDB.createVote(self.user_id, self.poll_id, self.poll.named, 0) self.assertTrue(voteWrapper.operationDone) voteWrapper: VotesWrapper = self.connection.votesDB.createVote(self.user_id2, self.poll_id, self.poll.named, 1) self.assertTrue(voteWrapper.operationDone) voteWrapper: VotesWrapper = self.connection.votesDB.createVote(self.user_id, self.poll_id2, self.poll2_noNamed.named, 0) self.assertTrue(voteWrapper.operationDone) voteWrapper: VotesWrapper = self.connection.votesDB.createVote(self.user_id2, self.poll_id2, self.poll2_noNamed.named, 1) self.assertTrue(voteWrapper.operationDone)
def setUp(self): self.connection = MongoDB() self.workout1 = { "name": 'Squat with weight', "category": 'Legs', "muscle_groups": ["Quads", "Glutes", "Core"], "advised_for": 'Women', "difficulty": 'Hard', "equipment": True, "sets": '4x15 10kg+10kg', "video_url": 'https://www.youtube.com/embed/MVMNk0HiTMg' } self.workout2 = { "name": 'Kickbacks', "category": 'Arms', "muscle_groups": ["Triceps"], "advised_for": 'Men', "difficulty": 'Medium', "equipment": True, "sets": '4x15 8kg+8kg', "video_url": 'https://www.youtube.com/embed/ShCYaoHmWmk' } workout_wrapper = self.connection.workoutDB.create(self.workout1) self.assertTrue(workout_wrapper.operationDone) self.workout1["_id"] = workout_wrapper.workout["_id"]
def setUp(self): self.connection = MongoDB() self.business1 = { "name": 'FitClub', "category": 'gym', "country": 'Greece', "city": 'Thessaloniki', "address": 'Diagora 20', "postal_code": '567 55', "phone_number": '2310 634590', "email": '*****@*****.**', "img_path": './assets/gym-preview.JPG', "services": ["service_1", "service_2"], "products": ['product_1', 'product_2'] } self.business2 = { "name": 'Planet Fitness', "category": 'gym', "country": 'Greece', "city": 'Athens', "address": '3 Septembriou Street 6', "postal_code": '576 45', "phone_number": '202-555-0376', "email": '*****@*****.**', "img_path": './assets/gym-preview.JPG', "services": ["service_1", "service_2"], "products": ['product_1', 'product_2'] } business_wrapper = self.connection.businessDB.create(self.business1) self.assertTrue(business_wrapper.operationDone) self.business1["_id"] = business_wrapper.business["_id"]
def setUp(self): self.connection = MongoDB() self.user1 = { "name" : "Alexandros", "surname" : "Wawaroutas", "email": "*****@*****.**", "password": "******", "birthdate": "27/02/1997", "role": "admin" } self.user2 = { "name" : "Georgios Alexandros", "surname" : "Vavaroutas", "email": "*****@*****.**", # same email "password": "******", "birthdate": "27/02/1997", "role": "admin" } self.user3 = { # new user "name" : "Dimitrios", "surname" : "Vrakas", "email": "*****@*****.**", "password": "******", "birthdate": "10/05/1977", "role": "admin" } user_wrapper = self.connection.userDB.create(self.user1) self.assertTrue(user_wrapper.operationDone) self.user1["_id"] = user_wrapper.user["_id"] self.assertTrue(self.connection.userDB._verifyPassword( user_wrapper.user["password"], self.user1["password"])) self.user1["password"] = user_wrapper.user["password"]
def setUp(self) -> None: # get connection, create a user, get its session_id, create a Poll object self.connection = MongoDB() self.user: User = User("mavroudo", "*****@*****.**", "1234") userWrapper: UserWrapper = self.connection.userDB.createNewUser( self.user.name, self.user.mail, self.user.password) self.assertIsNotNone(userWrapper.object) self.assertIsNotNone(userWrapper.object.session_id) self.session_id = userWrapper.object.session_id # get user id from session_id (user, user_id) = self.connection.userDB.getUserWithSessionId( self.session_id) self.assertIsNotNone(user) self.assertNotEqual(user_id, "") self.poll: Poll = Poll("how cool are we?", ["A lot", "A lot but second", "same as 2"], named=True, unique=True, creator_user_id=user_id) pollWrapper: PollWrapper = self.connection.pollsDB.createPoll( self.poll.question, self.poll.options, self.poll.named, self.poll.unique, user_id) self.assertTrue(pollWrapper.operationDone) self.assertIsNotNone(pollWrapper.object) self.poll_id = pollWrapper.pollId
def login(): user = request.get_json() # get username and password # connection with mongo sending user and getting answer if this user exists or not try: user_wrapper: UserWrapper = MongoDB.logIn(user) except TypeError as type_err: # Checking for errors return str(type_err), 422 except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if type(user_wrapper.user) is not dict: return "Something is wrong with the database", 500 if not user_wrapper.found: return "User does not exist", 404 if not user_wrapper.operationDone: return "Wrong password", 401 return jsonify(user={ "_id": user_wrapper.user["_id"], "name": user_wrapper.user["name"], "surname": user_wrapper.user["surname"], "email": user_wrapper.user["email"], "privilegeLevel": user_wrapper.user["privilegeLevel"], "token": user_wrapper.user["token"], "favoriteWorkout": user_wrapper.user["favoriteWorkout"], "favoriteBusiness": user_wrapper.user["favoriteBusiness"] })
def decorated(*args, **kwargs): token = request.headers["Authorization"] if not token: return "token is missing", 401 user_wrapper = MongoDB.getUser({"token": token}) if not user_wrapper.found: return "token is invalid", 403 return f(*args, **kwargs)
def get_workouts(): try: workout_list_wrapper: WorkoutListWrapper = MongoDB.getAllWorkouts() except: return "Bad error", 500 else: if type(workout_list_wrapper.workout_list) is not list: return "Something is wrong with the database", 500 return jsonify(data=workout_list_wrapper.workout_list)
def getCities(): try: cities_list = MongoDB.getCities() except: return "Bad error", 500 else: if cities_list is None: return "Something is wrong with the database", 500 return jsonify(data=cities_list)
def setUp(self) -> None: self.connection = MongoDB() # this will connect to mongo self.user1 = User("mavroudo", "*****@*****.**", "1234") self.user2_same_mail = User("mavroudo2", "*****@*****.**", "4567") self.user3 = User("kalliopi", "*****@*****.**", "789") userWrapper: UserWrapper = self.connection.userDB.createNewUser( self.user1.name, self.user1.mail, self.user1.password) self.assertTrue(userWrapper.operationDone) self.session_id = userWrapper.object.session_id
def delete_workouts(): delete_query = request.get_json() try: deleted_successfull = MongoDB.deleteWorkouts(delete_query) except: return "Bad error", 500 else: if not deleted_successfull: return "Could not delete workouts", 400 return jsonify("Workouts deleted successfully")
def manageAllBusinessesDisplay(): #connection with mongo getting all the existed business entries try: business_wrapper_list : BusinessWrapper = MongoDB.getAllBusinesses() except: return "Bad error", 500 else: if business_wrapper_list.business_list is None: return "Something is wrong with the database", 500 if type(business_wrapper_list.business_list) is list and not business_wrapper_list.found and not business_wrapper_list.operationDone: return "Couldn't get businesses", 500 return jsonify(businessList=business_wrapper_list.business_list)
def removeFavoriteWorkout(): business = request.get_json() try: favorite = MongoDB.removeFavoriteWorkout(business) except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if not favorite: return "Couldn't remove entry", 400 return jsonify("Workout removal successful")
def addFavoriteBusiness(): business = request.get_json() try: favorite = MongoDB.addFavoriteBusiness(business) except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if not favorite: return "Couldn't add entry", 400 return jsonify("Addition successful")
def manageAllUsersDisplay(): #connection with mongo getting all the existed user entries try: user_wrapper_list: UserListWrapper = MongoDB.getAllUsers() except: return "Bad error", 500 else: if user_wrapper_list.user_list is None: return "Something is wrong with the database", 500 if type(user_wrapper_list.user_list) is list and not user_wrapper_list.found and not user_wrapper_list.operationDone: return "Couldn't get users", 500 return jsonify(userList=user_wrapper_list.user_list)
def addFavoriteWorkout(): workout=request.get_json() #get new workout #connection with mongo sending the filters and creating the workout try: favorite = MongoDB.addFavoriteWorkout(workout) except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if favorite is False: return ("Couldn't add entry"), 400 return jsonify("Addition successful")
def manageBusinessDelete(): entries = request.get_json() #get entries for delete #connection with mongo sending the entry try: response = MongoDB.deleteBusinesses(entries) except TypeError as type_err: #Checking for errors return str(type_err), 422 except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if not response: return "Couldn't delete business entries", 500 return jsonify("Deletion successful")
def manageUserDelete(): users=request.get_json() #get users for delete #connection with mongo sending the id try: response = MongoDB.deleteUsers(users) except TypeError as type_err: #Checking for errors return str(type_err), 422 except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if response is False: return "Coudn't delete user entries", 500 return jsonify("Delete successful")
def getMyBusiness(): user = request.get_json() #connection with mongo sending the user and modifying the profile's details try: business_list_wrapper: BusinessListWrapper = MongoDB.getUserBusinesses(user) except TypeError as type_err: #Checking for errors return str(type_err), 422 except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if type(business_list_wrapper.business_list) is not list: return "Couldn't get users", 500 return jsonify(data=business_list_wrapper.business_list)
def displayFavoriteWorkout(): user=request.get_json() #connection wit mongo sending the user and getting his favorite workout try: workout_list = MongoDB.getFavoriteWorkout(user) except TypeError as type_err: #Checking for errors return str(type_err), 422 except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if workout_list is None: return "Something is wrong with the database", 500 else: return jsonify(workoutList=workout_list)
def update_workout(): new_workout = request.get_json() try: workout_wrapper: WorkoutWrapper = MongoDB.updateWorkout(new_workout) except TypeError as type_err: return str(type_err), 422 except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if type(workout_wrapper.workout) is not dict: return "Something is wrong with the database", 500 if not workout_wrapper.found: return "Workout doesn't exist in the database", 404 return jsonify("Workout update successfull")
def displayFavoritePlaces(): user=request.get_json() #connection wit mongo sending the user and getting his favorite places try: business_list = MongoDB.getFavoriteBusiness(user) except TypeError as type_err: #Checking for errors return str(type_err), 422 except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if business_list is None: return "Something is wrong with the database", 500 else: return jsonify(businessList=business_list)
def getWorkout(): filters=request.get_json() #get chosen filters by user #connection with mongo sending the filters and getting the matched workout try: workout_wrapper_list : WorkoutListWrapper = MongoDB.workoutSearch(filters) except TypeError as type_err: #Checking for errors return str(type_err), 422 except ValueError as value_err: return str(value_err), 422 return "Bad error", 500 else: if workout_wrapper_list.workout_list is None: return "Something is wrong with the database", 500 if type(workout_wrapper_list.workout_list) is list and not workout_wrapper_list.found and not workout_wrapper_list.operationDone: return "Couldn't find workout with these filters", 404 return jsonify(workoutList=workout_wrapper_list.workout_list)
def displayMyprofile(): user=request.get_json() #connection with mongo sending the user and modifying the profile's details try: user_wrapper: UserWrapper = MongoDB.getUser(user) except TypeError as type_err: #Checking for errors return str(type_err), 422 except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if user_wrapper.user is None: return "Something is wrong with the database", 500 if type(user_wrapper.user) is dict and not user_wrapper.found and not user_wrapper.operationDone: return "User does not exist", 404 return jsonify(user=user_wrapper.user)
def manageUserModify(): user=request.get_json() #get modifying user's details #connection with mongo sending the details of modified entry try: user_wrapper: UserWrapper = MongoDB.updateUser(user) except TypeError as type_err: #Checking for errors return str(type_err), 422 except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if user_wrapper.user is None: return "Something is wrong with the database", 500 if type(user_wrapper.user) is dict and not user_wrapper.operationDone and not user_wrapper.found: return "Couldn't update user entry", 500 return jsonify("Save successful")
def search(): filters=request.get_json() #get chosen filters by user #connection with mongo sending the fitlers and return the matched place try: business_wrapper_list : BusinessListWrapper = MongoDB.businessSearch(filters) except TypeError as type_err: #Checking for errors return str(type_err), 422 except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if business_wrapper_list.business_list is None: return "Something is wrong with the database", 500 if type(business_wrapper_list.business_list) is list and not business_wrapper_list.found and not business_wrapper_list.operationDone: return "Couldn't find businesses with these filters", 404 return jsonify(data=business_wrapper_list.business_list)
def manageOneUserDisplay(): user=request.get_json() #get user for display #connection with mongo getting the current user entry try: user_wrapper: UserWrapper = MongoDB.getUser(user_id) except TypeError as type_err: #Checking for errors return str(type_err), 422 except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if user_wrapper.user is None: return "Something is wrong with the database", 500 if type(user_wrapper.user) is dict and not user_wrapper.operationDone and not user_wrapper.found: return "Couldn't find user", 500 return jsonify(user=user_wrapper.user)
def manageOneBusinessDisplay(): entry=request.get_json() #get entry's id for display #connection with mongo getting all current business entry try: business_wrapper : BusinessWrapper = MongoDB.getBusiness(entry) except TypeError as type_err: #Checking for errors return str(type_err), 422 except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if business_wrapper.business is None: return "Something is wrong with the database", 500 if type(business_wrapper.business) is dict and not business_wrapper.operationDone and not business_wrapper.found: return "Couldn't find business", 500 return jsonify(business=business_wrapper.business)
def deleteWorkout(): workout=request.get_json() #get workout for delete #connection with mongo sending the filters and deleting the workout try: workout_wrapper : WorkoutWrapper = MongoDB.deleteWorkout(workout) except TypeError as type_err: #Checking for errors return str(type_err), 422 except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if workout_wrapper.workout is None: return "Something is wrong with the database", 500 if workout_wrapper.found and not workout_wrapper.operationDone: return "Couldn't delete user", 500 return jsonify("Delete successful")
def create_workout(): workout = request.get_json() try: workout_wrapper: WorkoutWrapper = MongoDB.createNewWorkout(workout) except TypeError as type_err: return str(type_err), 422 except ValueError as value_err: return str(value_err), 422 except: return "Bad error", 500 else: if type(workout_wrapper.workout) is not dict: return "Something is wrong with the database", 500 if workout_wrapper.found: return "Workout already exists", 409 if not workout_wrapper.operationDone: return "Couldn't create workout entry", 500 return jsonify("Creation successful")