def cria_tabela_quadrado(current_cursor: CursorBase, log: bool = False) -> int:
"""Cria a tabela Quadrado no banco de dados.
Args:
current_cursor (CursorBase): Cursor aberto que executará as queries.
log (bool, optional): Ativa e desativa o logging. Default é False.
Returns:
int: 1 se a tabela foi criada com sucesso.
2 se a tabela não foi criada.
"""
try:
current_cursor.execute("CREATE TABLE Quadrado ( \
id_dono INT NOT NULL, \
linha CHAR(1) NOT NULL, \
coluna CHAR(1) NOT NULL, \
n_jogada INT NOT NULL, \
estado CHAR(1) NOT NULL, \
id_navio INT NOT NULL, \
PRIMARY KEY (id_dono, linha, coluna, n_jogada), \
CONSTRAINT FK_JogadorQuadrado FOREIGN KEY (id_dono) REFERENCES Jogador(id_jogador))")
if log:
print("Tabela Quadrado criada")
return 1
except Exception as e:
if log:
print("Tabela Quadrado não foi criada", e)
return 0
def usa_banco(current_cursor: CursorBase,
nome: str = "Modular",
log: bool = False) -> int:
"""Faz o cursor usar o banco.
Args:
current_cursor (CursorBase): Um cursor aberto e conectado a um banco de dados.
nome (str, optional): Nome do banco que o cursor deve usar. Default é "Modular".
log (bool, optional): Ativa e desativa o logging. Default é False.
Returns:
int: 1 se o cursor estiver agora usando o banco.
2 se o cursor não conseguiu começar a usar o banco.
"""
try:
query = f"USE {nome}"
current_cursor.execute(query)
if log:
print(f"Usando banco {nome}")
return 1
except Exception as e:
if log:
print("Banco não foi usado", e)
return 0
def retorna_jogador(id_jogador: int,
current_cursor: CursorBase,
log: bool = False) -> Union[Tuple, int]:
"""Obtém um jogador do banco de dados.
Args:
id_jogador (int): Id do jogador que se deseja obter.
current_cursor (CursorBase): Cursor aberto que executará as queries.
log (bool, optional): Ativa e desativa o logging. Default é False.
Returns:
Union[Tuple, int]: Tupla com os dados do jogador caso tenha funcionado ou
0 caso alguma coisa tenha dado errado.
"""
try:
query = f"SELECT * FROM Jogador WHERE id_jogador={id_jogador}"
current_cursor.execute(query)
if log:
print(current_cursor.rowcount, f"Jogador {id_jogador} selecionado")
return current_cursor.fetchone()
except Exception as e:
if log:
print("Jogador não foi selecionado", e)
return 0
def atualiza_quantidade_navios_jogador(id_jogador: int,
id_navio: int,
quantidade: int,
current_cursor: CursorBase,
log: bool = False) -> int:
"""Atualiza no banco de dados a quantidade de navios de um tipo que um jogador tem.
Args:
id_jogador (int): A id do jogador que será atualizado.
id_navio (int): A id do navio que será atualizado.
quantidade (int): Qual a nova quantidade de navios que o jogador tem.
current_cursor (CursorBase): Cursor aberto que executará as queries.
log (bool, optional): Ativa e desativa o logging. Default é False.
Returns:
int: 1 se o jogador teve seus navios atualizados.
0 se o jogador não teve seus navios atualizados.
"""
try:
query = f"UPDATE Jogador SET navios_tipo_{id_navio + 1} = {quantidade} WHERE id_jogador={id_jogador}"
current_cursor.execute(query)
if log:
print(current_cursor.rowcount,
f"Navios do jogador {id_jogador} atualizado")
return 1
except Exception as e:
if log:
print("Navios do jogador não foi atualizado", e)
return 0
def get_departments(cursor: CursorBase) -> list:
"""
Get a list of the names of all departments in the database, using
the given cursor.
"""
cursor.execute(DEPARTMENTS_QUERY)
return [d[0] for d in cursor.fetchall()]
def get_usernames(cursor: CursorBase) -> list:
"""
Get a list of the usernames of all users in the database, using
the given cursor.
"""
cursor.execute(USERNAMES_QUERY)
return [d[0] for d in cursor.fetchall()]
def populate_courses_table_with_new_courses(cursor: CursorBase) -> None:
cursor.execute(
"SELECT %s, %s FROM %s" %
(TBLCol.course_number, TBLCol.course_name, TBL.Courses)
)
courses_already_in_db = cursor.fetchall()
course_to_add_list = [
course for course in mit_courses
if course not in courses_already_in_db
]
if len(course_to_add_list) > 0:
course_population_data = (
TBL.Courses,
TBLCol.course_number,
TBLCol.course_name,
",".join(
["(" + ",".join(
[quote(s) for s in course_row]
) + ")" for course_row in course_to_add_list]
),
)
cursor.execute(
"INSERT INTO %s (%s, %s) VALUES %s;" %
course_population_data
)
def create_response_table(cursor: CursorBase) -> None:
responses_data = (
TBL.Responses,
TBLCol.response_id,
TBLCol.course_number,
TBLCol.response_salt,
TBLCol.time_created,
)
cursor.execute("""
CREATE TABLE IF NOT EXISTS %s (
%s SERIAL,
-- the course name is extremely unlikely to change
-- over a long time. so having that as a safe key
-- reference for the course is needed whereas course
-- ids are arbitrary. so we retrieve courses with
-- course names
%s TINYTEXT,
-- response salts are just random strings that are
-- generated at creation time in order to fetch the
-- response id (since ids are incremented
-- automatically).
%s VARCHAR(10),
%s DATETIME(6)
);
""" % responses_data)
def cria_quadrado_banco(id_dono: int, linha: int, coluna: int, n_jogada: int, estado: str, id_navio: int, current_cursor: CursorBase, log: bool = False) -> int:
"""Cria um quadrado no banco de dados.
Args:
id_dono (int): Id do dono do quadrado.
linha (int): Linha em que o quadrado está no tabuleiro.
coluna (int): Coluna em que o quadrado está no tabuleiro.
n_jogada (int): Jogada em que ele foi criado. 0 se antes do primeiro ataque feito.
estado (str): O estado do navio no tabuleiro.
id_navio (int): Id do navio a qual aquele quadrado pertence.
current_cursor (CursorBase): Cursor aberto que executará as queries.
log (bool, optional): Ativa e desativa o logging. Default é False.
Returns:
int: 1 se o quadrado foi criado com sucesso.
0 se o quadrado não foi criado.
"""
try:
query = f"INSERT INTO Quadrado(id_dono, linha, coluna, n_jogada, estado, id_navio) VALUES ({id_dono}, {linha}, {coluna}, {n_jogada}, '{estado}', {id_navio})"
current_cursor.execute(query)
if log:
print(current_cursor.rowcount, "Quadrado inserido")
return 1
except Exception as e:
if log:
print("Não inseriu o quadrado", e)
return 0
def atualiza_placar_jogador(id_jogador: int,
placar: int,
current_cursor: CursorBase,
log: bool = False) -> int:
"""Atualiza o placar do jogador no banco de dados.
Args:
id_jogador (int): A id do jogador que será atualizado.
placar (int): O novo placar do jogador.
current_cursor (CursorBase): Cursor aberto que executará as queries.
log (bool, optional): Ativa e desativa o logging. Default é False.
Returns:
int: 1 se o jogador foi atualizado no banco de dados.
0 se o jogador não foi atualizado.
"""
try:
query = f"UPDATE Jogador SET placar={placar} WHERE id_jogador={id_jogador}"
current_cursor.execute(query)
if log:
print(current_cursor.rowcount,
f"Placar do jogador {id_jogador} atualizado")
return 1
except Exception as e:
if log:
print("Placar do jogador não foi atualizado", e)
return 0
def cria_tabela_jogador(current_cursor: CursorBase, log: bool = False) -> int:
"""Cria tabela Jogador onde os dados do jogador ficarão.
Args:
current_cursor (CursorBase): Cursor aberto que executará as queries.
log (bool, optional): [description]. Ativa e desativa o logging.
Returns:
int: 1 se a tabela for criada com sucesso.
0 se a tabela não for criada.
"""
try:
current_cursor.execute("CREATE TABLE Jogador ( \
id_jogador INT AUTO_INCREMENT PRIMARY KEY, \
nome VARCHAR(30) NOT NULL, \
navios_tipo_1 INT NOT NULL, \
navios_tipo_2 INT NOT NULL, \
navios_tipo_3 INT NOT NULL, \
navios_tipo_4 INT NOT NULL, \
tamanho_tipo_1 INT NOT NULL, \
tamanho_tipo_2 INT NOT NULL, \
tamanho_tipo_3 INT NOT NULL, \
tamanho_tipo_4 INT NOT NULL, \
placar INT NOT NULL, \
maximo_pontos INT NOT NULL \
)")
if log:
print("Tabela Jogador criada")
return 1
except Exception as e:
if log:
print("Tabela Jogador não foi criada", e)
return 0
def does_user_exist(cursor: CursorBase, username: str) -> bool:
"""
Return whether or not a user with the given username exists
in the database, using the given cursor
"""
cursor.execute(SELECT_USER, (username, ))
cursor.fetchall()
return cursor.rowcount > 0
def create_cfr(cursor: CursorBase, user: User):
"""
Insert a new cfr into cfr_department table
for the department represented by the given user in the
currently active semester, using the given cursor.
"""
semester = get_active_semester(cursor)
query = (user.dept_name, semester[0], semester[1], user.username)
cursor.execute(NEW_CFR_DEPT, query)
def get_active_semester(cursor: CursorBase) -> tuple:
"""
Get the currently active semester, using the given cursor.
The returned value is a tuple representing the season
and cal_year of the semester (in that order)
"""
cursor.execute(ACTIVE_SEMESTER_QUERY)
return cursor.fetchone()
def get_semesters(cursor: CursorBase) -> list:
"""
Get a list of all the semesters in the database, using the
given cursor.
The returned list is a list of tuples representing the
season and cal_year of a semester (in that order).
"""
cursor.execute(SEMESTERS_QUERY)
return cursor.fetchall()
def create_courses_table(cursor: CursorBase) -> None:
courses_data = (
TBL.Courses,
TBLCol.course_id,
TBLCol.course_number,
TBLCol.course_name,
)
cursor.execute("""
CREATE TABLE IF NOT EXISTS %s (
%s SERIAL,
%s TINYTEXT NOT NULL,
%s TINYTEXT NOT NULL
);
""" % courses_data)
def create_response_mapping_table(cursor: CursorBase) -> None:
response_mappings_query_data = (
TBL.ResponseMappings,
TBLCol.response_id,
TBLCol.question_id,
TBLCol.answer_id,
)
cursor.execute("""
CREATE TABLE IF NOT EXISTS %s (
%s BIGINT UNSIGNED NOT NULL,
%s BIGINT UNSIGNED NOT NULL,
%s BIGINT UNSIGNED NOT NULL
);
""" % response_mappings_query_data)
def cria_jogador_banco(nome: str,
navios_tipo_1: int,
navios_tipo_2: int,
navios_tipo_3: int,
navios_tipo_4: int,
tamanho_tipo_1: int,
tamanho_tipo_2: int,
tamanho_tipo_3: int,
tamanho_tipo_4: int,
placar: int,
maximo_pontos: int,
current_cursor: CursorBase,
log: bool = False) -> int:
"""Insere um jogador no banco de dados.
Args:
nome (str): Nome do jogador.
navios_tipo_1 (int): Navios do tipo 1 ainda a ser posicionados.
navios_tipo_2 (int): Navios do tipo 2 ainda a ser posicionados.
navios_tipo_3 (int): Navios do tipo 3 ainda a ser posicionados.
navios_tipo_4 (int): Navios do tipo 4 ainda a ser posicionados.
tamanho_tipo_1 (int): Tamanho do navio tipo 1 para essa partida.
tamanho_tipo_2 (int): Tamanho do navio tipo 2 para essa partida.
tamanho_tipo_3 (int): Tamanho do navio tipo 3 para essa partida.
tamanho_tipo_4 (int): Tamanho do navio tipo 4 para essa partida.
placar (int): Placar do jogador.
maximo_pontos (int): Pontos que o jogador precisa para vencer essa partida.
current_cursor (CursorBase): Cursor aberto que executará as queries.
log (bool, optional): Ativa e desativa o logging. Default é False.
Returns:
int: 1 se o jogador foi inserido com sucesso.
0 se o jogador não foi inserido.
"""
try:
query = f"INSERT INTO Jogador(nome, navios_tipo_1, navios_tipo_2, navios_tipo_3, navios_tipo_4, \
tamanho_tipo_1, tamanho_tipo_2, tamanho_tipo_3, tamanho_tipo_4, \
placar, maximo_pontos) VALUES ('{nome}', {navios_tipo_1}, {navios_tipo_2}, {navios_tipo_3}, {navios_tipo_4}, \
{tamanho_tipo_1}, {tamanho_tipo_2}, {tamanho_tipo_3}, {tamanho_tipo_4}, {placar}, {maximo_pontos})"
current_cursor.execute(query)
if log:
print(current_cursor.rowcount, "Jogador inserido")
return 1
except Exception as e:
if log:
print("Não inseriu o jogador", e)
return 0
def get_course_approvals(cursor: CursorBase, cfr: tuple) -> list:
"""
Get a list of the approval information for the courses associated with the
given cfr, using the given cursor.
The returned value is a list of tuples with fields corresponding to the
'approver' and 'commitment_code_ columns in the database.
cfr should be a tuple with the following fields (in this order):
dept_name, semester, cal_year, [date_initial], [date_revised],
revision_num, [cfr_submitter], [dean_committed]
(fields in brackets are not used, but this order is still expected)
"""
cfr_data = (cfr[0], cfr[1], cfr[2], cfr[5])
cursor.execute(SELECT_COURSE_APPROVALS, cfr_data)
return cursor.fetchall()
def create_answer_choice_table(cursor: CursorBase) -> None:
answer_choices_query_data = (
TBL.AnswerChoices,
TBLCol.answer_id,
TBLCol.question_id,
TBLCol.choice,
TBLCol.vector,
)
cursor.execute("""
CREATE TABLE IF NOT EXISTS %s (
%s SERIAL,
%s BIGINT UNSIGNED NOT NULL,
%s TEXT NOT NULL,
%s TEXT NOT NULL
);
""" % answer_choices_query_data)
def get_all_revisions_for_semester(cursor: CursorBase, dept_name: str,
semester: tuple) -> list:
"""
Get all the cfr revisions for the given department in the given semester,
using the given cursor.
semester should be a tuple containing the season and
cal_year of the semester (in that order).
The returned value is a list of tuples with the following fields (in this order):
dept_name, semester, cal_year, date_initial, date_revised,
revision_num, cfr_submitter, dean_committed
"""
query = (dept_name, semester[0], semester[1])
cursor.execute(SELECT_REVISIONS, query)
return cursor.fetchall()
def get_savings(cursor: CursorBase, cfr: tuple) -> list:
"""
Get a list of the salary savings entries associated with the given cfr,
using the given cursor.
The returned value is a list of tuples with fields corresponding
to SAL_FIELDS
cfr should be a tuple with the following fields (in this order):
dept_name, semester, cal_year, [date_initial], [date_revised],
revision_num, [cfr_submitter], [dean_committed]
(fields in brackets are not used, but this order is still expected)
"""
cfr_data = (cfr[0], cfr[1], cfr[2], cfr[5])
cursor.execute(SELECT_SAVINGS, cfr_data)
return cursor.fetchall()
def create_questions_table(cursor: CursorBase) -> None:
questions_query_data = (
TBL.Questions,
TBLCol.question_id,
TBLCol.question,
TBLCol.question_type,
TBLCol.question_answer_type,
)
cursor.execute("""
CREATE TABLE IF NOT EXISTS %s (
%s SERIAL,
%s TEXT NOT NULL,
%s TINYTEXT NOT NULL,
%s TINYTEXT NOT NULL
)
""" % questions_query_data
)
def get_current_cfr(cursor: CursorBase, dept_name: str) -> tuple:
"""
Get the latest cfr for the given department in the currently
active semester, using the given cursor.
The returned value is a tuple with the following fields (in this order):
dept_name, semester, cal_year, date_initial, date_revised,
revision_num, cfr_submitter, dean_committed
This will return None if there are no CFRs for the department
"""
semester = get_active_semester(cursor)
query = (dept_name, semester[0], semester[1])
cursor.execute(SELECT_CFR_DEPT, query)
result = cursor.fetchone()
return result
def create_new_revision(cursor: CursorBase, user: User):
"""
Creates a new revision (a new cfr) for the department
represented by the given user in the currently
active semester, using the given cursor.
If no cfrs exist yet for the department, one will
be created.
"""
current = get_current_cfr(cursor, user.dept_name)
if current is None:
create_cfr(cursor, user)
else:
revision = current[5] + 1
data = (current[0], current[1], current[2], current[3], revision,
user.username, current[7])
cursor.execute(NEW_REVISION, data)
def add_delete_constraints_if_needed(cursor: CursorBase) -> None:
fk_insertion_data = [
(
TBL.AnswerChoices,
"fk_answer_choices_to_question_id",
TBLCol.question_id,
TBL.Questions,
TBLCol.question_id,
),
(
TBL.ResponseMappings,
"fk_response_mappings_to_response_id",
TBLCol.response_id,
TBL.Responses,
TBLCol.response_id,
),
(
TBL.ResponseMappings,
"fk_response_mappings_to_question_id",
TBLCol.question_id,
TBL.Questions,
TBLCol.question_id,
),
(
TBL.ResponseMappings,
"fk_response_mappings_to_answer_id",
TBLCol.answer_id,
TBL.AnswerChoices,
TBLCol.answer_id,
),
]
for query_data in fk_insertion_data:
try:
cursor.execute("""
ALTER TABLE %s
ADD CONSTRAINT %s FOREIGN KEY (%s)
REFERENCES %s (%s)
ON DELETE CASCADE;
""" % query_data)
except mysql.connector.errors.IntegrityError:
# integrity error means we ran into the duplicate key,
# so table already had it
pass
def dropa_tabela_jogador(current_cursor: CursorBase, log: bool = False) -> int:
"""Deleta a tabela Jogador do banco de dados.
Args:
current_cursor (CursorBase): [description]
log (bool, optional): [description]. Defaults to False.
Returns:
int: [description]
"""
try:
query = f"DROP TABLE Jogador"
current_cursor.execute(query)
if log:
print(current_cursor.rowcount, "Tabela Jogador removida")
return 1
except Exception as e:
if log:
print("Não removeu a Tabela Jogador", e)
return 0
def retorna_ultima_jogada(id_jogador_1: int, id_jogador_2: int, current_cursor: CursorBase, log: bool = False) -> int:
"""Retorna o número da última jogada feita na partida.
Args:
id_jogador_1 (int): Id do primeiro jogador da partida.
id_jogador_2 (int): Id do segundo jogador da partida.
current_cursor (int): Cursor aberto que executará as queries.
log (bool, optional): Ativa e desativa o logging. Default é False.
Returns:
int: O número da última jogada feita na partida ou -1 caso alguma coisa
tenha dado errado.
"""
try:
query_1 = f"SELECT MAX(n_jogada) FROM Quadrado WHERE id_dono = {id_jogador_1}"
current_cursor.execute(query_1)
max_jogador_1 = current_cursor.fetchone()[0]
query_2 = f"SELECT MAX(n_jogada) FROM Quadrado WHERE id_dono = {id_jogador_2}"
current_cursor.execute(query_2)
max_jogador_2 = current_cursor.fetchone()[0]
ultima_jogada = max(max_jogador_1, max_jogador_2)
if log:
print(current_cursor.rowcount, "Ultima jogada obtida")
return ultima_jogada
except Exception as e:
if log:
print("Não obteve a ultima jogada", e)
return -1
def dropa_tabela_quadrado(current_cursor: CursorBase, log: bool = False) -> int:
"""Deleta a tabela Quadrado do banco de dados.
Args:
current_cursor (int): Cursor aberto que executará as queries.
log (bool, optional): Ativa e desativa o logging. Default é False.
Returns:
int: 1 se a tabela foi removida com sucesso.
0 se a tabela não foi removida.
"""
try:
query = f"DROP TABLE Quadrado"
current_cursor.execute(query)
if log:
print(current_cursor.rowcount, "Tabela Quadrado removida")
return 1
except Exception as e:
if log:
print("Não removeu a Tabela Quadrado", e)
return 0
def le_ultimo_id_jogador(current_cursor: CursorBase, log: bool = False) -> int:
"""Retorna do banco de dados o maior id_jogador da tabela Jogador.
Args:
current_cursor (CursorBase): Cursor aberto que executará as queries.
log (bool, optional): Ativa e desativa o logging. Default é False.
Returns:
int: O maior id_jogador registrado no banco de dados caso dê certo.
-1 caso algum erro ocorra.
"""
try:
query = "SELECT id_jogador FROM Jogador ORDER BY id_jogador DESC LIMIT 1"
current_cursor.execute(query)
last_id = current_cursor.fetchone()
if log:
print(current_cursor.rowcount, "Id jogador retornado")
return last_id[0]
except Exception as e:
if log:
print("Id jogador não retornado", e)
return -1