def addItemToDb(item_json_data): item_id = item_json_data["id"] if session.query(Item).filter(Item.itemId == item_id).first() is not None: return item_name = item_json_data["name"] item_media_id = item_json_data["media"]["id"] item_media_url = item_json_data["media"]["key"]["href"] addMedia(item_media_url, item_media_id) item_class = item_json_data["item_class"]["id"] item_subclass = item_json_data["item_subclass"]["id"] item_inventory_type = item_json_data["inventory_type"]["name"] item_purchase_price = item_json_data["purchase_price"] if ( "purchase_price" in item_json_data) else 0 stat_dict = {} if "stats" in item_json_data["preview_item"].keys(): try: stat_dict = organizeStats(item_json_data["preview_item"]["stats"]) except: print(item_id, item_json_data) item = Item(item_id, item_class, item_subclass, item_name, item_media_id, item_inventory_type, item_purchase_price, **stat_dict) session.add(item) if "azerite_class_powers" in item_json_data: addAzeriteTraits(item_json_data["azerite_class_powers"], item_id) session.commit()
def addMedia(media_url, media_id): if session.query(Media).filter( Media.mediaId == media_id).first() is not None: return media_obj = Media(media_id, media_url) session.add(media_obj) session.commit()
def add_all_auctions(auctions: GetAuction): print(len(auctions.auctions)) auctions.auctions.sort(key=lambda auc: auc.item.id) set_auctions_dirty() current_item = auctions.auctions[0].item.id addItemById(current_item) count = 0 for auction in auctions.auctions: count += 1 if count % 2000 == 0 and count != 0: print("Amount Processed:", count) item_id = auction.item.id if item_id != current_item: resp = addItemById(item_id) if resp is None: continue current_item = item_id insert_or_update_auc(auction) session.commit() remove_dirty_auctions() session.commit() print(count)
def addPlayerClassIfNotPresent(class_name, class_id): if session.query(PlayerClass).filter( PlayerClass.playerClassId == class_id).first() is not None: return player_class_obj = PlayerClass(class_id, class_name) session.add(player_class_obj) session.commit()
def register_user(user_name): if get_user_by_name(user_name): return None obj = WebUser(uuid.uuid4().hex, user_name, '{}') session.add(obj) session.commit() return User(obj.userId, obj.userName, obj.data)
def addAzeriteTraitsForClass(item_id, traits_json, player_class_id): for trait in traits_json: power_id = trait["spell"]["id"] if session.query(AzeriteTrait).filter( AzeriteTrait.power_id == power_id).first() is not None: return tier = trait["tier"] name = trait["spell"]["name"] azerite_obj = AzeriteTrait(power_id, tier, name, player_class_id) session.add(azerite_obj) session.commit() if "allowed_specializations" in trait: for spec in trait["allowed_specializations"]: player_class_spec_id = spec["id"] player_class_spec_name = spec["name"] addPlayerClassSpecializationIfNotPresent( player_class_id, player_class_spec_id, player_class_spec_name) relation = AzeriteClassSpecialization(player_class_spec_id, power_id) session.add(relation) azerite_item_obj = AzeriteItem(item_id, power_id) session.add(azerite_item_obj) session.commit()
def delete(self, data): customer = session.query(UsersDbTable).filter_by(token=data['token']).first() if customer is not None: session.delete(customer) session.commit() else: abort(409)
def addAllItemClassToDb(item_class_data: List[itemclass.ItemClass]): for c in item_class_data.item_classes: item_name = c.name item_id = c.id item_class = ItemClass(item_id, item_name) session.add(item_class) session.commit()
def clean_auction(auction_id, new_quantity): session.query(Auction).filter(Auction.auctionId == auction_id).update({ Auction.dirty: 0, Auction.quantity: new_quantity }) session.commit()
def addPlayerClassSpecializationIfNotPresent(class_id, spec_id, spec_name): if session.query(PlayerClassSpecialization).filter( PlayerClassSpecialization.playerClassSpecId == spec_id).first() is not None: return spec_class_obj = PlayerClassSpecialization(spec_id, class_id, spec_name) session.add(spec_class_obj) session.commit()
def addAllEncounters(encounter_data): for journal_id, encounters in encounter_data.items(): for encounter in encounters: encounter_name, encounter_id = encounter encount_obj = Encounter.Encounter(encounter_id, journal_id, encounter_name) session.add(encount_obj) session.commit()
def prefill_users(clean=True, amount=1000): if clean: session.query(User).delete() for counter in range(amount): user = User(email=faker.email(), password=generate_password(), name=faker.name()) session.add(user) user = User(email="admin", password="******", name="Administrator") session.add(user) session.commit()
def prefill_movies(clean=True): if clean: session.query(Movie).delete() data = pd.read_csv('../data/movies_metadata.csv') titles = data["original_title"] for title in titles: movie = Movie(name=title) session.add(movie) session.commit()
def addAllEncounterItems(encounter_items_data): for encounter_id, encounter_items in encounter_items_data.items(): for encounter_item in encounter_items: item_id, item_name = encounter_item addItemById(item_id) encount_item_obj = EncounterItems.EncounterItems( encounter_id, item_id) session.add(encount_item_obj) session.commit()
def cancel(self, id): if id.isdigit() == False: return build_error_response(+3, "Bad ID.") q = session.query(ReservationDbTable).filter_by(id=id).first() if q is not None: session.delete(q) session.commit() else: return build_error_response(-2, "Reservation does not exist.") return build_error_response(0, 'All done.')
def update(self, id, data): allowed_changes = ['id_restaurant', 'date', 'nb_people'] if not data: return build_error_response(-1, "Not enough parameters.") q = session.query(ReservationDbTable).filter_by(id=id).first() if q is not None: for key in allowed_changes: if key in data: q.set_value_by_name(key, data[key]) session.commit() return build_error_response(0, 'All done.')
def prefill_ratings(clean=True, max_amount=30): if clean: session.query(Rating).delete() movies = session.query(Movie).all() users = session.query(User).all() for user in users: sampled_movies = random.sample(movies, random.randint(0, max_amount)) for movie in sampled_movies: rating = Rating(user_id=user.id, movie_id=movie.id, mark=random.randint(1, 5)) session.add(rating) session.commit()
def update(self, id, data): allowed_changes = ['name', 'description', 'address', 'seats', 'longitude', 'latitude'] if not data: return build_error_response(-1, "Not enough parameters.") q = session.query(RestaurantsDbTable).filter_by(id = id).first() if q is not None: for key in allowed_changes: if key in data: q.set_value_by_name(key, data[key]) session.commit() else: return build_error_response(-2, 'Restaurant does not exist.') return build_error_response(0, 'All done.')
def create(self, data): check_filter = ['name', 'description', 'id_restaurant', 'price'] if (check_params(data, check_filter) == False): return build_error_response(-1, 'Not enough parameters.') if self.check_restaurant(data['id_restaurant']) == False: return build_error_response(-2, 'Restaurant does not exist.') dish = DishDbTable() dish.name = data['name'] dish.description = data['description'] dish.id_restaurant = data['id_restaurant'] dish.price = data['price'] session.add(dish) session.commit() return (build_error_response(0, 'All done.'))
def create(self, data): check_filter = ['name', 'description', 'address', 'owner_id', 'seats', 'longitude', 'latitude'] if (check_params(data, check_filter) == False): return build_error_response(-1, 'Not enough parameters.') restaurant = RestaurantsDbTable() restaurant.name = data['name'] restaurant.address = data['address'] restaurant.description = data['description'] restaurant.owner_id = data['owner_id'] restaurant.seats = data['seats'] restaurant.longitude = data['longitude'] restaurant.latitude = data['latitude'] session.add(restaurant) session.commit() return (build_error_response(0, 'All done.'))
def work_on_user(self, user_id): user_ratings = session.query(Rating).filter_by(user_id=user_id).all() ratings_number = len(user_ratings) user_recommendations = session.query(Recommendation).filter_by( user_id=user_id).all() recommendations_number = len(user_recommendations) if ((recommendations_number == 0 and ratings_number > Constants.MIN_RATINGS_TO_RECOMMEND) or ratings_number % (Constants.MIN_RATINGS_TO_RECOMMEND / 2) == 0): # Basically if user did >20 and has no recommendations or did 30, 40, 50 and so on ratings - make # new recommendations self.initialise_rater() session.query(Recommendation).filter_by(user_id=user_id).delete() session.commit() self.generate_recommendations_for_user(user_id)
def delete(self, id): if id.isdigit() == False: return build_error_response(+3, "Bad ID.") q = session.query(RestaurantsDbTable).filter_by(id = id).first() if q is not None: q2 = session.query(ReservationDbTable).filter_by(id_restaurant=id).all() q3 = session.query(DishDbTable).filter_by(id_restaurant=id).all() for i in q2: session.delete(i) for i in q3: session.delete(i) session.delete(q) session.commit() else: return build_error_response(-2, "Restaurant does not exist.") return build_error_response(0, 'All done.')
def search(): try: check_logged_in() user = get_current_user() data = {"person_name": user.name} print(request.form) if "rank" in request.form and "movie_id" in request.form: # Redirected here after adding like movie = session.query(Movie).filter_by(id=request.form["movie_id"]).first() session.add(Rating(user_id=user.id, movie_id=movie.id, mark=request.form["rank"])) session.commit() RecEng().work_on_user(user.id) data["message"] = "Your like {} for movie '{}' was added".format(request.form["rank"], movie.name) return go_to_page("search", data) except AuthorisationException: return redirect(url_for('login'))
def generate_recommendations_for_user(self, user_id): recommendations = self.rater.get_ratings(user_id) recommendations = trim_watched_recommendations(user_id, recommendations) recommendations_keys = sorted( recommendations, key=recommendations.get, reverse=True)[:Constants.RECOMMENDATIONS_PER_USER] new_recommendations = {} for key in recommendations_keys: new_recommendations[key] = recommendations[key] for movie_id in new_recommendations: session.add( Recommendation(user_id=user_id, movie_id=movie_id, expected_mark=new_recommendations[movie_id])) session.commit()
def update(self, data): customer = session.query(UsersDbTable).filter_by(email=data['email']).first() if customer is None: abort(400) else: customer.name = customer.name if (data['name'] == '' or data['name'] == None) else data['name'] customer.surname = customer.surname if (data['surname'] == '' or data['surname'] == None) else data['surname'] customer.email = customer.email if (data['email'] == '' or data['email'] == None) else data['email'] customer.password = customer.password if (data['password'] == '' or data['password'] == None) else sha256_crypt.encrypt(data['password']) customer.pseudo = customer.pseudo if (data['pseudo'] == '' or data['pseudo'] == None) else data['pseudo'] customer.type = customer.type if (data['type'] == '' or data['type'] == None) else data['type'] session.add(customer) session.commit() return ( {'name': customer.name, 'surname': customer.surname, 'email': customer.email, 'pseudo': customer.pseudo, 'type': customer.type, 'token': customer.token, 'id': customer.id})
def create_account(): try: check_logged_in() return redirect(url_for(DEFAULT_PAGE)) except AuthorisationException: try: email = request.form['email'] password = request.form["password"] name = request.form["name"] session.add(User(name=name, email=email, password=password)) session.commit() resp = redirect(url_for(DEFAULT_PAGE)) resp.set_cookie('email', email) resp.set_cookie('password', password) return resp except Exception: return redirect('/register?error="UnknownError')
def register(self, data): customer = session.query(UsersDbTable).filter_by(email=data['email']).first() if customer is None: bits = random.getrandbits(126) token = hex(bits) customer = UsersDbTable(name=data['name'], surname=data['surname'], email=data['email'], password=sha256_crypt.encrypt(data['password']), pseudo=data['pseudo'], type=data['type'], token=token) session.add(customer) session.commit() return customer.token else: abort(409)
def place(self, data): check_filter = ['id_restaurant', 'date', 'id_user', 'nb_people'] if check_params(data, check_filter) == False: return build_error_response(-1, 'Not enough parameters.') err_code = self.check_availibility(data['id_restaurant'], data['date'], data['nb_people']) if err_code == -1: return build_error_response(-5, 'Restaurant does not exist.') elif err_code == -2: return build_error_response(-6, 'Not enough seats.') reservation = ReservationDbTable() reservation.id_restaurant = data['id_restaurant'] reservation.date = data['date'] reservation.id_user = data['id_user'] reservation.nb_people = data['nb_people'] session.add(reservation) session.commit() return build_error_response(0, 'All done.')
def prefill_ratings_from_csv(clean=True): if clean: session.query(Rating).delete() data = pd.read_csv('../data/ratings_small.csv') user_ids = data["userId"] movie_ids = data["movieId"] ratings = data["rating"] ratings_sql = [] for index in range(len(user_ids)): ratings_sql.append(Rating(user_id=user_ids[index].item(), movie_id=movie_ids[index].item(), mark=ratings[index].item())) counter = 0 for rating_sql in ratings_sql: counter += 1 if counter % 1000 == 0: print("{}/{}".format(counter, len(ratings_sql))) try: session.add(rating_sql) if counter % 100 == 0: session.commit() except IntegrityError: session.rollback() print("Skipping, violates constraints")
def remove_dirty_auctions(): session.query(Auction).filter(Auction.dirty == 1).update( {Auction.dateRemoved: datetime.datetime.now()}) session.commit()
def addAllDungeons(mythic_dung_data): for dung in mythic_dung_data: dung_name, journal_id, mythic_id = dung dungeon_inst = Dungeon.Dungeon(mythic_id, journal_id, dung_name) session.add(dungeon_inst) session.commit()
def clean_recommendations(): session.query(Recommendation).delete() session.commit()
def set_auctions_dirty(): session.query(Auction).filter(Auction.dirty == 0).update( {Auction.dirty: 1}) session.commit()
def addItemSubClassToDb(item_class_id: int, item_subclass_id: int, item_subclass_name: str): item_subclass = ItemSubClass(item_subclass_id, item_class_id, item_subclass_name) session.add(item_subclass) session.commit()
def update_data(user_id, new_data): session.query(WebUser).filter(WebUser.userId == user_id).update( {WebUser.data: new_data}) session.commit()