def login_info(self, packet: LoginInfoPacket, address: Address):
login_code = 0x01
user = None
key = ''
try:
user = Database.authenticate(packet.username, packet.password)
if not user:
user = Database.create_user(packet.username, packet.password)
key = SessionManager.create_session(address, user.user_id)
except InvalidPasswordException:
login_code = 0x06
res = LoginInfoPacket(
login_code=login_code,
user_key=key,
char_ip=self.server.config['world']['ip'],
char_port=self.server.config['world']['port'],
chat_ip=self.server.config['chat']['ip'],
chat_port=self.server.config['chat']['port'],
ip='127.0.0.1',
locale='US',
first_login_sub=user.first_login_sub if user else False,
free_to_play=user.free_to_play if user else False,
error=None)
self.server.send(res, address)
def store_main_model_in_db(model, scaler_X, scaler_y):
database = Database()
database.create_table(CREATE_MODEL_QUERY)
database.drop_table(DELETE_ALL_MODELS_QUERY)
pickled_tuple = ModelStorage.__get_tuple_pickled(
(model, scaler_X, scaler_y))
database.insert_data(INSERT_MODEL_QUERY, pickled_tuple)
database.close_connection()
def get_sells_model_from_db():
database = Database()
get_data = database.fetch_all_data(GET_SELLS_MODEL_QUERY)[0]
database.close_connection()
unpickled_model = ModelStorage.__get_unpickled(get_data[1])
unpickled_scalers_tuple = ModelStorage.__get_tuple_unpickled(
(get_data[2], get_data[3]))
return unpickled_model, unpickled_scalers_tuple, get_data[4]
def _fetch_all_data(self, query: str, named_values: List[str]):
try:
database = Database()
data = database.fetch_all_data(query)
self.__handle_data(data, named_values)
except:
self._response = self._build_response(data=jsonify(
{"message": "Internal server error"}),
status_code=500)
finally:
database.close_connection()
def character_list(self, packet: CharacterListPacket, address: Address):
session = SessionManager.get_session(address)
user = Database.get_user(session['user_id'])
self.server.send(
CharacterListPacket(user.front_character, user.characters),
address)
def character_create(self, packet: CharacterCreateRequestPacket,
address: Address):
session = SessionManager.get_session(address)
user = Database.get_user(session['user_id'])
names = AssetLoader.load_names()
name = names[0][packet.predef1].strip() + names[1][
packet.predef2].strip() + names[2][packet.predef3].strip()
# TODO: generate starter kit
char = Character(user=user,
name=name,
unapproved_name=packet.name,
shirt_color=packet.shirt_color,
shirt_style=packet.shirt_style,
pants_color=packet.pants_color,
hair_style=packet.hair_style,
hair_color=packet.hair_color,
lh=packet.lh,
rh=packet.rh,
eyebrow_style=packet.eyebrow_style,
eye_style=packet.eye_style,
mouth_style=packet.mouth_style)
char.save()
self.server.send(CharacterCreateResponsePacket(0x00), address)
self.character_list(CharacterListPacket(), address)
def _insert(self, query: str, data: List[str]):
tuple_data = tuple(data)
try:
database = Database()
_id = database.insert_data(query, tuple_data)
self._response = self._build_response(data=jsonify({
"message": "Successful POST request",
"_id": _id
}),
status_code=201)
except psycopg2.errors.UniqueViolation:
self._response = self._build_response(data=jsonify(
{"message": "Item already exists"}),
status_code=400)
except:
self._response = self._build_response(data=jsonify(
{"message": "Internal server error"}),
status_code=500)
finally:
database.close_connection()
def _update_item(self, query: str, _id: str, data: List[str] or str
or None):
if isinstance(data, list):
tuple_data = tuple(data)
else:
tuple_data = data
try:
database = Database()
print(tuple_data)
_id = database.update_item(query, tuple_data, _id)
self._response = self._build_response(data=jsonify({
"message": "Successful PUT request",
"_id": _id
}),
status_code=200)
except:
self._response = self._build_response(data=jsonify(
{"message": "Internal server error"}),
status_code=500)
finally:
database.close_connection()
def get_by_label(label):
batch_fields = Database.find_by('images', {"label": label})
batch_images = []
for field in batch_fields:
fs_file = Database.FS.get(field['fields'])
label_file = field["label"]
base64_data = codecs.encode(fs_file.read(), 'base64')
image = base64_data.decode('utf-8')
img_str = "data:image/png;base64," + image
# jsonImg = json.dumps(img_str)
batch_images.append({"url": img_str, "label": label_file})
return batch_images
def get_by_label():
images = Database.get_all('images')
list_images = []
for img in images:
label_file = img['label']
fs_file = Database.FS.get(img["fields"])
base64_data = codecs.encode(fs_file.read(), 'base64')
image = base64_data.decode('utf-8')
img_str = "data:image/png;base64," + image
# jsonImg = json.dumps(img_str)
list_images.append({"url": img_str, "label": label_file})
return jsonify(images=list_images)
def all(page_number, page_size, search_query=None):
with Database() as db:
if not search_query:
rows = db.execute('''select distinct games.game_id, games.name, games.description, games.all_reviews, games.release_date,developers.developer_name, publishers.publisher_name, genres.genre_name, games.minimum_requirements, games.recommended_requirements, games.original_price
FROM games
LEFT JOIN game_developers
ON games.game_id = game_developers.game_id
LEFT JOIN developers
ON game_developers.developer_id = developers.developer_id
LEFT JOIN game_publishers
ON games.game_id = game_publishers.game_id
LEFT JOIN publishers
ON game_publishers.publisher_id = publishers.publisher_id
LEFT JOIN game_genres
ON games.game_id = game_genres.game_id
LEFT JOIN genres
ON game_genres.genre_id = genres.genre_id
GROUP BY games.game_id
LIMIT {} OFFSET {}'''
.format(
page_size,
page_size*(page_number - 1))).fetchall()
return [Games(*row) for row in rows]
rows = db.execute('''select distinct games.game_id, games.name, games.description, games.all_reviews, games.release_date,developers.developer_name, publishers.publisher_name, genres.genre_name, games.minimum_requirements, games.recommended_requirements, games.original_price
FROM games
LEFT JOIN game_developers
ON games.game_id = game_developers.game_id
LEFT JOIN developers
ON game_developers.developer_id = developers.developer_id
LEFT JOIN game_publishers
ON games.game_id = game_publishers.game_id
LEFT JOIN publishers
ON game_publishers.publisher_id = publishers.publisher_id
LEFT JOIN game_genres
ON games.game_id = game_genres.game_id
LEFT JOIN genres
ON game_genres.genre_id = genres.genre_id
WHERE instr(name, "{}") > 0
GROUP BY games.game_id
LIMIT {} OFFSET {}
'''
.format(
search_query,
page_size,
page_size*(page_number - 1))).fetchall()
return [Games(*row) for row in rows]
def _drop_table(self, query: str):
try:
database = Database()
database.drop_table(query)
self._response = self._build_response(data=jsonify(
{"message": "Successful DELETE request"}),
status_code=200)
except:
self._response = self._build_response(data=jsonify(
{"message": "Internal server error"}),
status_code=500)
finally:
database.close_connection()
def get(id):
with Database() as db:
rows = db.execute(
'''SELECT games.game_id, games.name, games.description, games.all_reviews, games.release_date,developers.developer_name, publishers.publisher_name, genres.genre_name, games.minimum_requirements, games.recommended_requirements, games.original_price
FROM games
LEFT JOIN game_developers
ON games.game_id = game_developers.game_id
LEFT JOIN developers
ON game_developers.developer_id = developers.developer_id
LEFT JOIN game_publishers
ON games.game_id = game_publishers.game_id
LEFT JOIN publishers
ON game_publishers.publisher_id = publishers.publisher_id
LEFT JOIN game_genres
ON games.game_id = game_genres.game_id
LEFT JOIN genres
ON game_genres.genre_id = genres.genre_id
WHERE games.game_id = {}
GROUP BY games.game_id'''
.format(id)).fetchall()
return [Games(*row) for row in rows][0]
def find_image(cls, id):
image = Database.find_by_id('images', id)
return cls(**image)
def get_stocks_to_offers_counter(self):
database = Database()
data = database.fetch_all_data(STOCK_TO_OFFER_ALL_QUERY)
self.__handle_stock_to_offer_dict(data)
return self._response
def initiliae_database():
Database.initialize(app)
def get_images(cls):
images = Database.get_images('images')
return [cls(**image) for image in images]
def set_label(self, label):
self.label = label
Database.update('images', cursor_id=self._id, updates={"label": label})
def count_sell_items():
database = Database()
database.create_table(CREATE_SELL_DATA_QUERY)
counter = database.fetch_all_data(GET_SELLS_COUNT_QUERY)[0][0]
database.close_connection()
return counter
def count_advise_items():
database = Database()
database.create_table(CREATE_ADVICE_TABLE_QUERY)
counter = database.fetch_all_data(GET_ITEMS_COUNTER_QUERY)[0][0]
database.close_connection()
return counter
def save_to_mongo(image, content_type, filename, label):
return Database.insert_image('images', image, content_type, filename,
label)
def _create_table(query: str):
database = Database()
database.create_table(query)
database.close_connection()
