def _setup_objetos(self, cria_banco):
controller_aluno = Controller(Aluno(aluno_nome_1), cria_banco)
controller_aluno.salva()
aluno = controller_aluno.pega_registro_por_id(id_=1)
controller_curso = Controller(Curso(curso_nome_1), cria_banco)
controller_curso.salva()
curso = controller_curso.pega_registro_por_id(id_=1)
Controller(InscricaoAlunoCurso(aluno_id=1, curso_id=1),
cria_banco).salva()
controller_materia = Controller(Materia(materia_nome_1), cria_banco)
controller_materia.salva()
materia_1 = controller_materia.pega_registro_por_id(id_=1)
controller_materia = Controller(Materia(materia_nome_1), cria_banco)
controller_materia.salva()
materia_2 = controller_materia.pega_registro_por_id(id_=2)
controller_materia = Controller(Materia(materia_nome_1), cria_banco)
controller_materia.salva()
materia_3 = controller_materia.pega_registro_por_id(id_=3)
Controller(AssociaCursoMateria(curso_id=1, materia_id=1),
cria_banco).salva()
Controller(AssociaCursoMateria(curso_id=1, materia_id=2),
cria_banco).salva()
Controller(AssociaCursoMateria(curso_id=1, materia_id=3),
cria_banco).salva()
controller_coordenador_geral = Controller(CoordenadorGeral(),
cria_banco)
controller_coordenador_geral.salva()
coordenador_geral = controller_coordenador_geral \
.pega_registro_por_id(id_=1)
curso.atualiza_materias(materia_1)
curso.atualiza_materias(materia_2)
curso.atualiza_materias(materia_3)
aluno.inscreve_curso(curso)
return coordenador_geral
def _cria_curso(argumentos):
nome_parametro = "--nome"
materias_parametro = "--materias"
numero_argumentos = 8
if nome_parametro in argumentos and materias_parametro in argumentos \
and len(argumentos) == numero_argumentos:
try:
nome = _pega_valor(argumentos, nome_parametro)
materia_1 = _pega_valor(argumentos, materias_parametro)
materia_2 = _pega_valor(argumentos, materias_parametro, 2)
materia_3 = _pega_valor(argumentos, materias_parametro, 3)
curso = Curso(nome)
controller_curso = Controller(curso, bd)
controller_curso.salva()
registro = controller_curso.pega_registro_por_nome(nome)
curso_id = registro.pega_id()
controller = Controller(Materia(None), bd)
for materia in [materia_1, materia_2, materia_3]:
registro = controller.pega_registro_por_nome(materia)
materia_id = registro.pega_id()
curso.atualiza_materias(Materia(materia))
Controller(AssociaCursoMateria(curso_id, materia_id),
bd).salva()
print(f"Curso de {curso.pega_nome()} criado.")
except Exception:
raise
else:
raise ListaParametrosInvalida(LISTA_PARAMETROS_INVALIDA)
def _atualiza_aluno(argumentos):
aluno_id = "--aluno-id"
situacao = "--situacao"
nome = "--nome"
materia = "--materia"
nota = "--nota"
aluno = Aluno()
try:
if aluno_id in argumentos:
id_ = _pega_valor(argumentos, aluno_id)
Controller(aluno, bd).atualiza(id_)
if nome in argumentos:
nome_ = _pega_valor(argumentos, nome)
aluno.define_nome(nome_)
Controller(aluno, bd).atualiza(id_)
if situacao in argumentos:
situacao_ = _pega_valor(argumentos, situacao)
aluno.define_situacao(situacao_)
Controller(aluno, bd).atualiza(id_)
if materia in argumentos and nota in argumentos:
materia_ = _pega_valor(argumentos, materia)
nota_ = _pega_valor(argumentos, nota)
materias = {materia_: nota_}
aluno.atualiza_materias_cursadas(materias)
Controller(aluno, bd).atualiza(id_)
print(f"Aluno com identificador {id_} atualizado com sucesso.")
except Exception:
raise
def test_aluno_pode_atualizar_situacao(self, cria_curso_materias_real):
aluno, curso, _ = cria_curso_materias_real
expected = "trancado"
Controller(InscricaoAlunoCurso(aluno, curso), self.bd).salva()
self._atualiza_aluno_por_cli(aluno.pega_id(), situacao=expected)
aluno = Controller(Aluno(), self.bd).pega_registro_por_id(aluno.pega_id())
actual = aluno.pega_situacao()
assert actual == expected
def cria_massa_dados(cria_banco_real):
bd = cria_banco_real
bd.deleta_tabela(cursos)
bd.deleta_tabela(alunos)
aluno_id = Controller(Aluno(aluno_nome_1), bd).salva()
curso_id = Controller(Curso(curso_nome_1), bd).salva()
yield aluno_id, curso_id
bd.deleta_tabela(cursos)
bd.deleta_tabela(alunos)
def test_aluno_inscrito_curso_salvo_banco_dados(self, cria_banco_real):
Controller(Aluno(aluno_nome_1), cria_banco_real).salva()
Controller(Curso(curso_nome_1), cria_banco_real).salva()
expected = [tuple((1, self.aluno_id, self.curso_id))]
parametros = [
"inscreve-aluno-curso", "--aluno-id", self.aluno_id, "--curso-id",
self.curso_id
]
executa_comando(parametros)
inscricao = InscricaoAlunoCurso(self.aluno_id, self.curso_id)
actual = Controller(inscricao, cria_banco_real).pega_registros()
assert actual == expected
def test_curso_associado_materia_criado_banco_dados(self, cria_banco):
associacao_id = 1
curso_id = 1
materia_id = 1
expected = [tuple((associacao_id, curso_id, materia_id))]
Controller(Curso(curso_nome_1), cria_banco).salva()
Controller(Materia(materia_nome_1), cria_banco).salva()
controller = Controller(AssociaCursoMateria(curso_id, materia_id),
cria_banco)
controller.salva()
actual = controller.pega_registro_por_id(associacao_id)
assert actual == expected
def test_situaca_aluno_muda_para__em_curso__apos_inscricao(
self, cria_banco_real):
Controller(Aluno(aluno_nome_1), cria_banco_real).salva()
Controller(Curso(curso_nome_1), cria_banco_real).salva()
expected = "em curso"
parametros = [
"inscreve-aluno-curso", "--aluno-id", self.aluno_id, "--curso-id",
self.curso_id
]
executa_comando(parametros)
InscricaoAlunoCurso(self.aluno_id, self.curso_id)
aluno = Controller(Aluno().define_id(self.aluno_id),
cria_banco_real).pega_registro_por_id(self.aluno_id)
actual = aluno.pega_situacao()
assert actual == expected
def run(self):
self.__is_running = True
while self.__is_running:
self.__print_menu()
option = int(input(" >> "))
if option == 0:
self.__map.load_from_binary_file("../assets/test1.map")
if option == 1:
self.__controller = Controller(self.__map)
self.best_solution = self.__controller.run()
print("--------------- BEST SOLUTION -------------------- \n")
print("--- Best Solution fitness: ", self.best_solution[0])
print("--- Best Solution path: ", end=" ")
for s in self.best_solution[1]:
print("(", s.x, ", ", s.y, ") ", end=" ")
elif option == 2:
self.do_before_running_gui()
self.__is_running_gui = True
time.sleep(1)
index = 0
while self.__is_running_gui:
self.__is_running_gui = self.__gui.render(
self.best_solution, index)
index += 1
time.sleep(0.2)
self.__gui.quit()
elif option == 3:
pass
elif option == 4:
self.visualize_map()
def run(self):
self.__is_running = True
while self.__is_running:
self.__print_menu()
option = int(input(" >> "))
if option == 0:
self.__map.load_from_binary_file("../assets/test1.map")
if option == 1:
self.__map.load_from_binary_file("../assets/test1.map")
self.__controller = Controller(self.__map)
self.__controller.run()
elif option == 2:
self.do_before_running_gui()
fittest_individual = self.__controller.fittest_individual
gene_index = 0
self.__is_running_gui = True
time.sleep(1)
while self.__is_running_gui:
if gene_index < INDIVIDUAL_SIZE:
self.__is_running_gui = self.__gui.render(
gene_index, fittest_individual)
gene_index += 1
time.sleep(0.5)
self.__gui.quit()
elif option == 3:
pass
elif option == 4:
self.visualize_map()
def main():
view = View()
ctrl = Controller(view)
view.inject_controller(ctrl)
if len(sys.argv) > 1:
view.onecmd(' '.join(sys.argv[1:]))
view.cmdloop()
def main():
environment_repository = EnvironmentRepository()
image_repository = ImageRepository()
controller = Controller(environment_repository, image_repository)
gui = GUI(controller)
gui.start()
def test_curso_criado_banco_dados(self, cria_banco):
curso_id = 1
expected = Curso(curso_nome_1).pega_nome()
controller = Controller(Curso(curso_nome_1), cria_banco)
controller.salva()
curso = controller.pega_registro_por_id(curso_id)
actual = curso.pega_nome()
assert actual == expected
def test_cria_materia_por_cli(self, cria_banco_real):
nome = materia_nome_1
expected = nome
parametros = ["cria-materia", "--nome", nome]
executa_comando(parametros)
materia = Materia(nome)
registro = Controller(materia, cria_banco_real).pega_registros()[0]
actual = registro.pega_nome()
assert actual == expected
def test_retorna_excecao_quando_curso_id_nao_existe(self, cria_banco_real):
expected = "Curso não encontrado."
Controller(Aluno(None), cria_banco_real).salva()
parametros = [
"inscreve-aluno-curso", "--aluno-id", self.aluno_id, "--curso-id",
self.curso_id
]
actual = executa_comando(parametros)
assert expected in actual
def test_aluno_pode_atualizar_nome(self, cria_massa_dados):
cria_massa_dados
aluno_id = "1"
nome = aluno_nome_2
expected = nome
self._atualiza_aluno_por_cli(aluno_id, nome)
aluno = Controller(Aluno(), self.bd).pega_registro_por_id(aluno_id)
actual = aluno.pega_nome()
assert actual == expected
def _cria_materia(argumentos):
nome = "--nome"
numero_argumentos = 4
if nome in argumentos and len(argumentos) == numero_argumentos:
nome = _pega_valor(argumentos, nome)
materia = Materia(nome)
Controller(materia, bd).salva()
print(f"Matéria de {materia.pega_nome()} criada.")
else:
raise ListaParametrosInvalida(LISTA_PARAMETROS_INVALIDA)
def cria_massa_dados_em_memoria(cria_banco):
Controller(Aluno(aluno_nome_1), cria_banco).salva()
Controller(Curso(curso_nome_1), cria_banco).salva()
Controller(Materia(materia_nome_1), cria_banco).salva()
Controller(Materia(materia_nome_2), cria_banco).salva()
Controller(Materia(materia_nome_3), cria_banco).salva()
Controller(AssociaCursoMateria(curso_id=1, materia_id=1),
cria_banco).salva()
Controller(AssociaCursoMateria(curso_id=2, materia_id=1),
cria_banco).salva()
Controller(AssociaCursoMateria(curso_id=3, materia_id=1),
cria_banco).salva()
Controller(InscricaoAlunoCurso(aluno_id=1, curso_id=1), cria_banco)
yield
cria_banco.deleta_tabela(cursos)
cria_banco.deleta_tabela(alunos)
def _cria_aluno(argumentos):
nome_parametro = "--nome"
numero_parametros = 4
if nome_parametro in argumentos and len(argumentos) == numero_parametros:
nome = _pega_valor(argumentos, nome_parametro)
aluno = Aluno(nome)
controller = Controller(aluno, bd)
controller.salva()
print(f"Aluno {nome} criado com sucesso.")
else:
raise ListaParametrosInvalida(LISTA_PARAMETROS_INVALIDA)
def test_aluno_pode_ser_inscrito_curso(self, cria_banco_real,
cria_curso_banco_real):
expected = (f"Aluno identificado por {self.aluno_id} inscrito no curso"
f" identificado por {self.curso_id}.")
Controller(Aluno(None), cria_banco_real).salva()
cria_curso_banco_real
parametros = [
"inscreve-aluno-curso", "--aluno-id", self.aluno_id, "--curso-id",
self.curso_id
]
actual = executa_comando(parametros)
assert actual == expected
def test_curso_criado_banco_dados(self):
self._cria_materias()
expected = Curso(curso_nome_1).pega_nome()
parametros = [
self._cria_curso, "--nome", curso_nome_1, "--materias",
materia_nome_1, materia_nome_2, materia_nome_3
]
executa_comando(parametros)
curso = Controller(Curso(curso_nome_1),
self._bd).pega_registros()[self.first]
actual = curso.pega_nome()
assert actual == expected
def cria_curso_materias_real(cria_banco_real):
bd = cria_banco_real
bd.deleta_tabela(cursos)
bd.deleta_tabela(alunos)
bd.deleta_tabela(materias)
aluno = Aluno(aluno_nome_1)
aluno = Controller(aluno, bd).salva()
curso = Curso(curso_nome_1)
curso = Controller(curso, bd).salva()
Controller(InscricaoAlunoCurso(aluno, curso), bd).salva()
lista_materias = [materia_nome_1, materia_nome_2, materia_nome_3]
lista_materia_obj = []
for materia in lista_materias:
materia_obj = Materia(materia)
materia_obj = Controller(materia_obj, bd).salva()
lista_materia_obj.append(materia_obj)
Controller(AssociaCursoMateria(curso, materia), bd).salva()
yield aluno, curso, lista_materia_obj
def _inscreve_aluno_curso(argumentos):
aluno_parametro = "--aluno-id"
curso_parametro = "--curso-id"
numero_parametros = 6
if aluno_parametro in argumentos and curso_parametro in argumentos \
and len(argumentos) == numero_parametros:
curso_id = _pega_valor(argumentos, curso_parametro)
aluno_id = _pega_valor(argumentos, aluno_parametro)
inscricao = InscricaoAlunoCurso(aluno_id, curso_id)
Controller(inscricao, bd).salva()
print(
f"Aluno identificado por {aluno_id} inscrito no curso identificado por {curso_id}."
)
else:
raise ListaParametrosInvalida(LISTA_PARAMETROS_INVALIDA)
import os #Para os imports funcionarem corretamente é necessário exportar a env variable PYTHONPATH os.environ["PYTHONPATH"] = os.path.abspath(os.path.dirname(__file__)) from src.controller.controller import Controller a = Controller() a.comeca()
import sys
sys.path.append('../')
from src.controller.controller import Controller
if __name__ == "__main__":
controller = Controller()
def setup(self, cria_banco):
self.controller = Controller(Aluno(aluno_nome_1), cria_banco)
self.controller.salva()
"""
Author: David Walshe
Date: 13 March 2021
"""
import logging
from src.view.view import MainWindow
from src.controller.controller import Controller
logger = logging.getLogger(__name__)
if __name__ == '__main__':
"""Run the GUI application"""
Controller().show()
def _cria_materias(self):
Controller(Materia(materia_nome_1), self._bd).salva()
Controller(Materia(materia_nome_2), self._bd).salva()
Controller(Materia(materia_nome_3), self._bd).salva()
def __init__(self):
self.controller = Controller()
self.porta = self.escolhaPorta()
def __init__(self, dispositivo):
self.__controller = Controller()
self.__dispositivo = dispositivo