def on_click_bt_on_sell(self):
from model.database import Database
db = Database()
db.update_player_on_sell(p_id=self.player.id, on_sell=1)
from model.my_player_store import my_player_store
my_player_store.update_from_db()
self.ON_SELL_PLAYER.emit()
def open_database(self):
dialog = QFileDialog()
if(self.model.gamestate.last_open_dir != None):
dialog.setDirectory(self.model.gamestate.last_open_dir)
filename = dialog.getOpenFileName(self.mainAppWindow.chessboard_view, self.mainAppWindow.trUtf8('Open PGN'), \
None, 'PGN (*.pgn)', QFileDialog.DontUseNativeDialog)
if filename:
db = Database(filename)
db.init_from_pgn(self.mainAppWindow,self.mainAppWindow.trUtf8("Scanning PGN File..."))
self.model.database = db
self.model.user_settings.active_database = db.filename
selectedGame = 0
if(db.no_of_games() > 1):
dlg = DialogBrowsePgn(db)
if dlg.exec_() == QDialog.Accepted:
items = dlg.table.selectedItems()
selectedGame = int(items[0].text())-1
else:
selectedGame = None
if(not selectedGame == None and db.no_of_games() > 0):
loaded_game = db.load_game(selectedGame)
self.model.gamestate.current = loaded_game
self.mainAppWindow.chessboard_view.update()
self.mainAppWindow.chessboard_view.emit(SIGNAL("statechanged()"))
self.mainAppWindow.save.setEnabled(False)
self.mainAppWindow.setLabels()
self.mainAppWindow.moves_edit_view.setFocus()
self.model.gamestate.last_open_dir = QFileInfo(filename).dir().absolutePath()
self.model.gamestate.init_game_tree(self.mainAppWindow)
self.mainAppWindow.moves_edit_view.setFocus()
def on_click_bt_delete(self):
from model.database import Database
db = Database()
db.delete_my_player(p_id=self.player.id)
from model.my_player_store import my_player_store
my_player_store.update_from_db()
self.ON_DELETE_PLAYER.emit()
def main():
''' Main function '''
database_handle = Database()
telegram_client = TelegramUserClient(database_handle)
client = Client(database_handle, telegram_client)
client.start()
client.idle()
def delete(self):
learning_material = str(request.form['learning-material'])
if learning_material == "Boy that Italian family over there sure is quiet":
db = Database()
db.delete_collection()
return "dropped"
return "not dropped"
def get_mentor_by_id(cls, idx):
db = Database()
query = """SELECT * FROM Mentor WHERE id =(?)"""
person = db.get(query, (idx, ))[0]
print(person)
new_mentor = Mentor(person[0], person[1], person[2], person[3],
person[4], person[5], person[6], person[7])
return new_mentor
def on_click_favorite(self):
from model.database import Database
db = Database()
favorite = 0 if self.player.favorite else 1
self.player.favorite = favorite
db.update_favorite(p_id=self.player.id, favorite=favorite)
self.update_ui()
self.ON_FAVORITE_CHANGED.emit()
def get_employee_by_id(cls, idx):
db = Database()
query = """SELECT * FROM Employee WHERE id =(?)"""
person = db.get(query, (idx, ))[0]
print(person)
new_employee = Employee(person[0], person[1], person[2], person[3],
person[4], person[5], person[6], person[7])
return new_employee
def keyPressEvent(self, e):
if type(e) == QKeyEvent and e.key() == Qt.Key_F1:
c.ech += 1
if c.ech > 3:
c.ech = 1
from model.database import Database
db = Database()
db.update_constant(c.ech)
self.close()
def on_click_save(self):
from model.database import Database
db = Database()
p_id = self.player.id
solding_price = int(self.sell_edit.text().replace(" ", ""))
db.update_player_solding(p_id, solding_price)
from model.my_player_store import my_player_store
my_player_store.update_from_db()
self.close()
def submit_answer(cls, answer_text, student_id, assigment_id):
db = Database()
task_type = db.get("SELECT Task_type FROM Assignments WHERE id=(?)",
(assigment_id, ))[0][0]
if task_type == "Personal":
cls.submit_personal_answer(answer_text, student_id, assigment_id)
elif task_type == "Team":
cls.submit_team_answer(answer_text, student_id, assigment_id)
db.close()
def main():
db = Database(mode='PROD', echo=True)
if not db.has_tables():
db.make_tables()
with open('.smurfs.txt') as f:
for line in f:
fetch_and_store_summoner(line.strip(), db)
session = db.SessionMaker()
print(session.query(GameStats, GameStats.champion).all())
def get_student_by_id(cls, idx):
db = Database()
query = """SELECT * FROM Student WHERE id =(?)"""
person = db.get(query, (idx, ))[0]
print(person)
person_object = Student(person[0], person[1], person[2], person[3],
person[4], person[5], person[6], person[7],
person[9], person[10])
db.close()
return person_object
def cli(ctx, db_host, db_port, db_password, db_username):
try:
logger.info(f"Connecting to mysql database {db_username}@{db_host}:{db_port}")
db = Database(host=db_host, port=db_port, username=db_username, password=db_password)
logger.info("Connected to database successfully.")
ctx.obj = db
except Exception as e:
click.echo("Unable to connect to the database")
click.echo(e)
sys.exit(1)
def get_list_of_mentors(cls):
list_of_mentors = []
db = Database()
query = """SELECT * FROM Mentor;"""
for person in db.get(query):
person_object = Mentor(person[0], person[1], person[2], person[3],
person[4], person[5], person[6], person[7])
list_of_mentors.append(person_object)
db.close()
return list_of_mentors
def get_list_of_students(cls):
list_of_students = []
db = Database()
query = """SELECT * FROM Student;"""
for person in db.get(query):
person_object = Student(person[0], person[1], person[2], person[3],
person[4], person[5], person[6], person[7],
person[9], person[10])
list_of_students.append(person_object)
db.close()
return list_of_students
def get(self, clientId, month):
db = Database(None)
df = Dataframe(None)
query = {"clientId": clientId, "month": month}
result = db.doQuery(self.db, self.coll, query)
orders = df.createDf(result)
if len(result) > 0:
orders = df.deleteCol(orders, "_id")
return df.toJson(orders, True)
def get_list_of_employees(cls):
list_of_employees = []
db = Database()
query = """SELECT * FROM Employee;"""
for person in db.get(query):
person_object = Employee(person[0], person[1], person[2],
person[3], person[4], person[5],
person[6], person[7])
list_of_employees.append(person_object)
db.close()
return list_of_employees
async def setUpClass(cls):
telegram_client = TelegramClient()
# A hack to ensure dispatcher exist
Dispatcher._set_singleton( # pylint: disable=W0212
telegram_client.updater.dispatcher) # pylint: disable=W0212
database_handle = Database(testing=True)
database_handle.drop_testing_database()
cls.client = Client(database_handle, telegram_client)
cls.client.start()
cls.user = TelegramUser()
await cls.user.start()
await cls.user.setup_chat()
def save(self):
db = Database()
values = (self.name, self.surname, self.email, self.date_of_birth,
self.city, self.phone, self.login, self.user_id)
if not self.user_id:
values = values[:-1]
query = """INSERT INTO Employee(Name, Surname, Email, Date_of_birth, City, Phone, Login) VALUES (?,?,?,?,?,?,?);"""
else:
query = """UPDATE Employee SET Name=(?), Surname=(?), Email=(?), Date_of_birth=(?), City=(?), Phone=(?), Login=(?) WHERE id =(?);"""
db.set(query, values)
db.close()
def on_click_save(self):
from model.database import Database
db = Database()
from utils.price import get_max_buy_price
p_id = self.player.id
buy_price = int(self.buy_edit.text().replace(" ", ""))
max_buy_price = get_max_buy_price(self.player.price)
db.add_my_player(player_id=p_id,
buy_price=buy_price,
max_buy_price=max_buy_price)
from model.my_player_store import my_player_store
my_player_store.update_from_db()
self.close()
def update_price(progress_bar):
value_progress_bar = 0
progress_bar.setValue(value_progress_bar)
player_store.players = []
for page_index in range(0, 100):
url = "https://www.futwiz.com/en/fifa19/players?page=" + str(
page_index)
query = requests.get(url)
page = query.content
html_data = BeautifulSoup(page, features="html.parser")
rows = html_data.find_all("tr", attrs={"table-row"})
for row in rows:
p = Player()
player = row.find("td", attrs={"player"})
tds = row.find_all("td", width=True)
price = None
for td in tds:
if td["width"] == "30":
price = td.string.strip()
price = int(price.replace(",", ""))
if price == 0:
continue
ovr = row.find("td", attrs={"ovr"})
gen = ovr.a.div.div.string
_type = ovr.a.div["class"][1]
_type = _type.replace("otherversion19-", "")
nom = player.find("p", attrs={"name"}).a.b.string
nom = nom.replace("'", "")
team = player.find("p", attrs={"team"})
index = 0
club = None
championnat = None
for string in team.strings:
if string and (not string.isspace()):
if index == 0:
club = string
if index == 2:
championnat = string
index += 1
p.nom = nom
p.club = club
p.championnat = championnat
p.gen = gen
p._type = _type
p.price = price
player_store.players.append(p)
from model.database import Database
db = Database()
db.update_price(nom=nom, price=price, type=_type, gen=gen)
value_progress_bar += 1
progress_bar.setValue(value_progress_bar)
def update_from_db(self):
self.my_players = []
from model.my_player import MyPlayer
from model.database import Database
db = Database()
my_players = db.get_my_players()
for player in my_players:
new_my_player = MyPlayer(player_id=player[0],
buy_price=player[1],
max_buy_price=player[2],
on_sell=player[3],
id=player[4],
solding_price=player[5])
self.my_players.append(new_my_player)
def get_assigment_by_id(task_id):
db = Database()
assigment_data = db.get("SELECT * FROM Assignments WHERE id=(?)",
(task_id, ))[0]
answers = db.get(
"SELECT * FROM Answers WHERE Assignment_ID=(?)",
(assigment_data[0], )) # get answers for assigment with a[0]-id
answers = [
Answer(d[0], d[1], d[2], d[3], d[4], d[5], d[6]) for d in answers
]
assigment_object = Assigment(assigment_data[0], assigment_data[1],
assigment_data[2], answers)
db.close()
return assigment_object
def submit_personal_answer(cls, answer_text, student_id, assigment_id):
db = Database()
is_answer_exist = db.get(
"SELECT EXISTS (SELECT * FROM Answers WHERE Student_ID=(?) AND Assignment_ID=(?))",
(student_id, assigment_id))
if is_answer_exist[0][0]:
db.set(
"UPDATE Answers SET Answer_text=(?) WHERE Student_ID=(?) AND Assignment_ID=(?)",
(answer_text, student_id, assigment_id))
else:
db.set(
"INSERT INTO Answers(Answer_text, Student_ID, Assignment_ID) VALUES (?,?,?)",
(answer_text, student_id, assigment_id))
db.close()
def create_on_startup(cls, parentWidget):
# default gamestate is just entering moves
gamestate = gs.GameState()
gamestate.mode = gs.MODE_ENTER_MOVES
# default active engine is the internal one (Stockfish)
user_settings = us.UserSettings()
user_settings.engines.append(us.InternalEngine())
user_settings.active_engine = user_settings.engines[0]
database = None
# if existing, recover game state, user settings, and
# database that user used before exiting app last time
# (by unpickling)
# TODO: replace by proper JSON serialization
fn = ad.user_data_dir(appname, appauthor)
save_dir = fn
try:
with open(fn+os.sep+"current.pgn") as pgn:
game = chess.pgn.read_game(pgn)
gamestate.current = game
gamestate.init_game_tree(mainAppWindow=parentWidget)
pgn.close()
except BaseException as e:
print(e)
pass
user_settings.load_from_file(fn+os.sep+"settings.ini")
if(not user_settings.active_database == None):
database = Database(user_settings.active_database)
else:
default_db_path = fn + os.sep + "mygames.pgn"
database = Database(default_db_path)
return Model(gamestate,database,user_settings, save_dir)
def new_database(self):
ret = self.mainAppWindow.gamestateController.unsaved_changes()
if(not ret == QMessageBox.Cancel):
file_dialog = QFileDialog()
filename = file_dialog.getSaveFileName(self.mainAppWindow, self.mainAppWindow.trUtf8('Create New PGN'), \
None, 'PGN (*.pgn)', QFileDialog.DontUseNativeDialog)
if(filename):
if(not filename.endswith(".pgn")):
filename = filename + ".pgn"
self.model.gamestate.last_save_dir = QFileInfo(filename).dir().absolutePath()
db = Database(filename)
db.create_new_pgn()
self.mainAppWindow.save.setEnabled(False)
self.model.database = db
self.model.user_settings.active_database = db.filename
self.mainAppWindow.moves_edit_view.setFocus()
def get_list_of_assigments():
db = Database()
assigments_data_list = db.get("SELECT * FROM Assignments")
assigments_objects_list = []
for a in assigments_data_list:
answers = db.get(
"SELECT * FROM Answers WHERE Assignment_ID=(?)",
(a[0], )) # get answers for assigment with a[0]-id
answers = [
Answer(d[0], d[1], d[2], d[3], d[4], d[5], d[6])
for d in answers
]
assigments_objects_list.append(Assigment(a[0], a[1], a[2],
answers))
db.close()
return assigments_objects_list
def submit_team_answer(cls, answer_text, student_id, assigment_id):
db = Database()
team_id = db.get("SELECT Team_ID FROM Student WHERE id=(?)",
(student_id, ))[0][0]
is_answer_exist = db.get(
"SELECT EXISTS (SELECT * FROM Answers WHERE Team_ID=(?) AND Assignment_ID=(?))",
(team_id, assigment_id))
if is_answer_exist[0][0]:
db.set(
"UPDATE Answers SET Answer_text=(?) WHERE Team_ID=(?) AND Assignment_ID=(?)",
(answer_text, team_id, assigment_id))
else:
db.set(
"INSERT INTO Answers(Answer_text, Team_ID, Assignment_ID) VALUES (?,?,?)",
(answer_text, team_id, assigment_id))
db.close()
