def create_database() -> None:
"""Procedura creaza o baza de date noua, goala, ce va retine informatiile necesare despre meciurile din Hattrick,
necesare simularii.
Algoritm:
---------
Daca fisierul deja exista in folderul 'db', atunci nu se intampla nimic si afiseaza un mesaj de eroare.
Altfel, creaza baza de date si afiseaza un mesaj de creare cu succes.
Parametri:
---------
Niciunul.
Intoarce:
---------
Nimic."""
if os.path.exists(global_library.database_file_path):
dw.show_error_window_in_thread(title='Fisier existent',
message='Baza de date deja exista.')
else:
Base.metadata.create_all(
create_engine(global_library.database_file_uri, echo=True))
dw.show_info_window_in_thread(title='Succes!',
message='Baza de date a fost creata.')
def delete_database():
if os.path.exists(global_library.database_file_path):
drop_database(global_library.database_file_uri)
dw.show_info_window_in_thread(title='Succes!',
message='Baza de date a fost stearsa.')
else:
dw.show_error_window_in_thread(title='Esec!',
message='Baza de date nu exista')
def create_database():
if os.path.exists(global_library.database_file_path):
dw.show_error_window_in_thread(title='Fisier existent',
message='Baza de date deja exista.')
else:
engine = create_engine(global_library.database_file_uri, echo=True)
Base.metadata.create_all(engine)
dw.show_info_window_in_thread(title='Succes!',
message='Baza de date a fost creata.')
def add_access_tokens_to_config_file(test_config: config,
connection: OAuth1Service,
request_token: str,
request_token_secret: str,
code: str) -> bool:
"""Functia adauga jetoanele access token si access token secret fisierului de configurari. Acestea vor fi
folosite pentru conectarea site-ului la contul Hattrick, fara a mai fi necesara parcurgerea din nou a intregului
proces de autentificare.
Algoritm:
----------
Incearca sa obtina cele doua jetoane. Daca nu reuseste, atunci cel mai probabil este deoarece PIN-ul este fie
introdus gresit, fie utilizatorul a renuntat in a-l introduce (care e cam acelasi lucru). Daca reuseste, atunci
le salveaza in fisierul de configurari.
Parametri:
----------
test_config: config
instanta a clasei config, definita in ConfigParser. Aceasta retine, printre altele si URL-ul catre fisierul
ce urmeaza a fi descarcat;
connection: OAuth1Service
instanta a clasei Oauth1Service, clasa ce retine detaliile necesare conectarii la Hattrick prin protocolul
oauth;
request_token: str
variabila ce retine un sir de caractere, denumit request token, folosit la conectarea la Hattrick si la
obtinerea jetoanelor de acces;
request_token_secret: str
variabila ce retine un sir de caractere, denumit request token secret, folosit la conectarea la Hattrick si
la obtinerea jetoanelor de acces;
code: str
variabila ce retine un sir de caractere, denumit request token secret, folosit la conectarea la Hattrick si
la obtinerea jetoanelor de acces. Acest sir se numeste cod si trebuie introdus de catre utilizator la
autentificarea aplicatiei la contul Hattrick.
Intoarce:
---------
True, daca procesul a avut loc cu succes. Acest lucru implica introducerea corecta a codului primit de catre
utilizator, fapt care are loc in functia get_access_token. Altfel, daca utilizatorul a introdus codul gresit
sau a renuntat in a-l introduce, intoarce False."""
try:
access_token, access_token_secret = connection.get_access_token(
request_token,
request_token_secret,
params={'oauth_verifier': code})
except KeyError:
dw.show_error_window_in_thread(title='Wrong PIN!',
message='Wrong PIN inserted.')
return False
else:
test_config['DEFAULT']['ACCESS_TOKEN'] = access_token
test_config['DEFAULT']['ACCESS_TOKEN_SECRET'] = access_token_secret
with open(file=global_library.configuration_file,
mode='w') as configfile:
test_config.write(configfile)
return True
def add_access_tokens_to_config_file(test_config, connection, request_token,
request_token_secret, code):
try:
access_token, access_token_secret = connection.get_access_token(
request_token,
request_token_secret,
params={'oauth_verifier': code})
except KeyError:
dw.show_error_window_in_thread(title='Wrong PIN!',
message='Wrong PIN inserted.')
return False
else:
test_config['DEFAULT']['ACCESS_TOKEN'] = access_token
test_config['DEFAULT']['ACCESS_TOKEN_SECRET'] = access_token_secret
with open(global_library.configuration_file, 'w') as configfile:
test_config.write(configfile)
return True
def delete_database() -> None:
"""Procedura sterge baza de date in care sunt retinute datele din meciurile importate din Hattrick.
Algoritm:
----------
Daca exista fisierul ce contine baza de date in folerul 'db', atunci il sterge si afiseaza un mesaj de confirmare.
Daca nu, atunci nu face nimic si afiseaza un mesaj de eroare.
Parametri:
----------
Niciunul
Intoarce:
----------
Nimic."""
if os.path.exists(global_library.database_file_path):
drop_database(global_library.database_file_uri)
dw.show_info_window_in_thread(title='Succes!', message='Baza de date a fost stearsa.')
else:
dw.show_error_window_in_thread(title='Esec!', message='Baza de date nu exista')
def import_matches_into_database() -> None:
"""Procedura ce ruleaza algoritmul de importare a evaluarilor necesare in baza de date, plecand de la
fisierele XML necesare, obtinute din Hattrick. Se apeleaza engine-ul de import, transmitandu-i limita
inferioara si cea superioara a numerelor de identificare ale meciurilor ce trebuie introduse.
Algoritm:
-----------
Incearca sa importe in baza de date meciurile cu numerele de identificare ce se afla intre cele doua limite. In
functie de exceptiile care apar, afiseaza mesajele de eroare corespunzatoare. Indiferent de reusita operatiei
de import, se revine la pagina panoului de control.
Parametri:
-----------
Niciunul.
Intoarce:
-----------
Nimic.
Exceptii:
------------
ValueError:
In casutele in care se introduc limitele specificate mai sus, nu sunt introduse valori numerice, intregi;
IndexError:
Una sau amandoua dintre limitele specificate mai sus au numere negative, sau 0;
sqlalchemy.exc.IntegrityError:
In intervalul specificat de cele doua limite exista minim un meci al carui numar de identificare exista
in baza de date."""
try:
import_matches.import_engine(low_end=int(request.form['InferiorLimit']),
high_end=int(request.form['SuperiorLimit']))
except ValueError:
dw.show_error_window_in_thread(title='Date introduse gresit!',
message='Trebuie sa introduci valori numerice intregi in ambele casute!')
except IndexError:
dw.show_error_window_in_thread(title='Numar inexistent!',
message='Numarul de identificare al unei limite (sau a ambelor) nu exista. Cel '
'mai probabil ai introdus numere mai mici sau egale cu 0, sau accesul '
'programului la Hattrick a fost oprit din contul utilizatorului.')
except sqlalchemy.exc.IntegrityError:
dw.show_error_window_in_thread(title='Meciuri existente',
message='In intervalul introdus este macar un meci care este in baza de date')
else:
dw.show_info_window_in_thread(title='Import terminat', message='Am importat toate meciurile alese')
return render_template('admin.html', title='Admin Control Panel')
def estimate_results(given_ratings: tuple) -> dict:
"""Functia de estimare a sanselor de castig pentru echipa gazda, pentru echipa oaspete si sansele ca meciul sa
se termine la egalitate, daca cele doua echipe au evaluarile introduse de catre utilizator.
Algoritm:
----------
Se creaza o instanta de clasa de tip engine si, pe baza acesteia, o instanta de tip sessionmaker, care se ocupa
de comunicarea cu BD. Apoi se ruleaza interogarea corespunzatoare, care intoarce un numar de randuri. Dupa rularea
interogarii, se inchide sesiunea. Daca interogarea intoarce unul sau mai multe randuri, se calculeaza rezultatele
dorite. Altfel, se afiseaza un mesaj corespunzator.
Parametri:
----------
given_ratings: tuple
tuplu ce retine cele 14 evaluari necesare. 7 pentru echipa gazda si 7 pentru echipa oaspete. Pentru fiecare
echipa sunt retinute, in ordine: mijlocul, apararea pe dreapta, centru si stanga si atacul pe dreapta, centru
si stanga.
Intoarce:
----------
Un dictionar cu raspunsul cautat."""
ans = {
'Home wins': 0,
'Draws': 0,
'Away wins': 0,
'Home goals average': 0,
'Away goals average': 0,
'Sum of home goals': 0,
'Sum of away goals': 0
}
engine = create_engine(global_library.database_file_uri, echo=True)
session_class = sessionmaker(bind=engine)
session = session_class()
records = session.query(
Matches.HomeTeamGoals, Matches.AwayTeamGoals
).filter(Matches.HomeTeamMidfield == given_ratings[0]).filter(
Matches.HomeTeamRDefense == given_ratings[1]
).filter(Matches.HomeTeamCDefense == given_ratings[2]).filter(
Matches.HomeTeamLDefense == given_ratings[3]).filter(
Matches.HomeTeamRAttack == given_ratings[4]).filter(
Matches.HomeTeamCAttack == given_ratings[5]).filter(
Matches.HomeTeamLAttack == given_ratings[6]
).filter(Matches.AwayTeamMidfield == given_ratings[7]).filter(
Matches.AwayTeamRDefense == given_ratings[8]
).filter(Matches.AwayTeamCDefense == given_ratings[9]).filter(
Matches.AwayTeamLDefense == given_ratings[10]
).filter(Matches.AwayTeamRAttack == given_ratings[11]).filter(
Matches.AwayTeamCAttack == given_ratings[12]).filter(
Matches.AwayTeamLAttack == given_ratings[13])
session.close()
if records.count() == 0:
dw.show_error_window_in_thread(
title='No match',
message='No matches with those ratings were found in the database')
return ans
for record in records:
ans['Sum of home goals'] += record.HomeTeamGoals
ans['Sum of away goals'] += record.AwayTeamGoals
if record.HomeTeamGoals > record.AwayTeamGoals:
ans['Home wins'] += 1
elif record.HomeTeamGoals == record.AwayTeamGoals:
ans['Draws'] += 1
else:
ans['Away wins'] += 1
ans['Home goals average'] = ans['Sum of home goals'] / records.count()
ans['Away goals average'] = ans['Sum of away goals'] / records.count()
return ans
def get_match_ratings_for_a_future_match() -> None:
"""Procedura obtine evaluarile echipei utilizatorului pentru un meci ce se va disputa in viitor, stabilit de
catre utilizator.
Algoritm:
----------
Se obtine numele de identificare al echipei pentru care se doreste obtinerea evaluarilor. In functie de aceasta,
se stabileste numele echipei si se descarca fisierul XML cu meciurile viitoare ale acesteia. Daca exista meciuri
viitoare, se stabileste daca utilizatorul a dorit meciurile unei alte echipe de pe cont sau a echipei sale.
Aceasta verificare este necesara pentru ca, daca utilizatorul a dorit sa vada meciurile viitoare ale unei alte
echipe din contul sau, se se selecteze automat primul meci din lista. Daca utilizatorul a dorit sa vada alt meci
al aceleiasi echipe, se citeste pozitia pe care se afla acel meci. Se descarca fisierul cu ordinele de meci pentru
meciul selectat, se stabileste daca echipa joaca acasa sau in deplasare si se afiseaza pagina utilizatorului
conectat la joc, cu evaluarile incarcate in pozitiile corecte.
Parametri:
----------
Niciunul.
Intoarce:
----------
Nimic."""
if not check_if_connection_is_valid(test_config=config):
dw.show_error_window_in_thread(title='Connection lost',
message='We cannot access anymore your Hattrick account. This is probably '
'because you revoked the application''s access from the Hattrick '
'account, or there is a problem with the Hattrick server!')
return render_template('index.html', title="The Best Match Predictor",
ratings=global_library.ratings, positions=global_library.positions,
statuses=global_library.statuses, from_index=True,
match_orders=global_library.default_match_orders,
answer=global_library.ans)
global_library.team_id = request.form['HattrickTeams']
global_library.user_team_name = get_user_team_name()
global_library.user_matches = download_user_matches_file.download_user_matches_file(global_library.team_id)
checked = get_chosen_option()
selected_position: int = 0
if len(global_library.user_matches) == 0:
dw.show_error_window_in_thread(title='No match found',
message='This team does not have any future matches of the selected types '
'scheduled')
match_orders = global_library.default_match_orders
place_to_play = 'Home'
else:
try:
if global_library.old_checked == checked:
match_id = request.form['FutureMatches']
for match in global_library.user_matches:
if match_id != match[0]:
selected_position += 1
else:
break
else:
match_id = global_library.user_matches[0][0]
except we.BadRequestKeyError:
match_id = global_library.user_matches[0][0]
match_orders = download_future_match.download_future_match(match_id=match_id,
team_id=global_library.team_id)
place_to_play = team_plays_home_or_away(match_id=match_id, team_to_test=global_library.user_team_name)
global_library.old_checked = checked
return render_template('connected.html', title="Connected to Hattrick", from_index=False,
ratings=global_library.ratings,
positions=global_library.positions, statuses=global_library.statuses,
user_data=global_library.user_data,
user_matches=global_library.user_matches,
match_orders=match_orders,
place=place_to_play,
answer=global_library.ans, checked=checked, position=selected_position)
