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()
