def __init__(self, nome, Faixa_Etaria):
Pessoa.__init__(self, nome)
self.faixa_etaria = Faixa_Etaria
self.lista_de_cuidados = SinglyLinkedList()
self.familia = None # Sting nome familia
self.profissionais_in = HashTable()
self.serviços_in = HashTable() # todos os serviços dentro de utente
class Profissional(Tad_Profissional,Pessoa):
def __init__(self, nome, categoria):
Pessoa.__init__(self,nome)
self.categoria=categoria
self.lista_de_cuidados = HashTable() # Keys=Utentes | Values=List
def get_categoria(self):
return self.categoria
def add_to_cuidados(self, cuidado):
utente= cuidado.get_utente()
if not self.get_cuidados().has_key(utente):
self.lista_de_cuidados.insert(utente,SinglyLinkedList())
utente_list = self.get_cuidados().get(utente)
utente_list.insert_last(cuidado)
def remove_utente_from_cuidados(self,utente):
self.get_cuidados().remove(utente)
def get_cuidados(self):
return self.lista_de_cuidados
def has_cuidados(self):
return self.get_cuidados().is_empty()
class ListController:
def __init__(self):
self.users = HashTable()
def has_user(self, user_name):
return self.users.has_key(user_name)
def add_user(self, user_name):
user = User(user_name)
self.users.insert(user_name, user)
def remove_user(self, user_name):
pass
def has_users(self):
pass
# Returns a singly linked list of users
def get_users(self):
pass
def has_task_list(self, user_name, task_list_name):
pass
def create_task_list(self, user_name, task_list_name):
pass
def remove_task_list(self, user_name, task_list_name):
pass
def has_task(self, user_name, task_list_name, task_id):
pass
def create_task(self, user_name, task_list_name, task_id,
task_description):
pass
def remove_task(self, user_name, task_list_name, task_id):
pass
def edit_task(self, user_name, task_list_name, task_id, task_description):
pass
def has_task_lists(self, user_name):
pass
def get_task_lists(self, user_name):
pass
def has_tasks(self, user_name, task_list_name):
pass
def get_tasks(self, user_name, task_list_name):
pass
def has_Task(self, user_name, task_list_name, task_id):
pass
def toggle_state(self, user_name, task_list_name, task_id):
pass
def test_is_full(self):
self.table = HashTable(size=7)
self.assertFalse(self.table.is_full())
self.insert_items(7)
self.assertTrue(self.table.is_full())
self.remove_items(1)
self.assertFalse(self.table.is_full())
def __init__(self):
self.checker = HashTable()
self.checker.insert("Servico", False)
self.checker.insert("Categoria", False)
self.checker.insert("Profissional", False)
self.checker.insert("CInvalida", False)
self.checker.insert("SInvalida", False)
class Familia():
def __init__(self, nome):
self.nome = nome
self.membros = HashTable()
def get_nome(self):
return self.nome
def get_membros(self):
return self.membros.values()
def add_member(self, member):
self.membros.insert(member.get_nome(), member)
def remove_member(self, member):
self.membros.remove(member.get_nome())
class Profissional():
def __init__(self, nome, categoria):
self.name = nome
self.categoria = categoria
self.lista_de_cuidados = HashTable()
def get_categoria(self):
return self.categoria
def add_to_cuidados(self, cuidado):
utente = cuidado.get_utente()
# ver se passo antes o objecto
if not self.lista_de_cuidados.has_key(utente):
pass
def __init__(self):
# ------------Dicionário-Geral------------
self.utentes = HashTable()
self.profissionais = HashTable()
self.familias = HashTable()
# ----------------------------------------
# { "Medicina":{ "Duarte" : Obj_Profissional } }
self.categorias = HashTable()
# { "Jovem": { "Duarte" : Obj_Utente } }
self.faixasetarias = HashTable()
# { "Consulta": { "Duarte" : [Obj_Cuidados] } }
self.servicos = HashTable()
self.tad_servicos = HashTable()
self.tad_faixasetarias = HashTable()
self.tad_categorias = HashTable()
# -------------------Tads----------------------
self.tad_categorias.insert("Medicina", 1)
self.tad_categorias.insert("Enfermagem", 2)
self.tad_categorias.insert("Auxiliar", 3)
self.tad_faixasetarias.insert("Jovem", 1)
self.tad_faixasetarias.insert("Adulto", 2)
self.tad_faixasetarias.insert("Idoso", 3)
self.tad_servicos.insert("Consula", 1)
self.tad_servicos.insert("PequenaCirurgia", 2)
self.tad_servicos.insert("Enfermagem", 3)
# ------------------Categorias-----------------
self.categorias.insert("Medicina", HashTable())
self.categorias.insert("Enfermagem", HashTable())
self.categorias.insert("Auxiliar", HashTable())
# -------------------Faixas-Etárias-------------
self.faixasetarias.insert("Adulto", HashTable())
self.faixasetarias.insert("Jovem", HashTable())
self.faixasetarias.insert("Idoso", HashTable())
# ----------------------Servicos-----------------------------
self.servicos.insert("Consulta", HashTable())
self.servicos.insert("PequenaCirurgia", HashTable())
self.servicos.insert("Enfermagem", HashTable())
def __init__(self, nome, categoria):
Pessoa.__init__(self,nome)
self.categoria=categoria
self.lista_de_cuidados = HashTable() # Keys=Utentes | Values=List
class Controller:
def __init__(self):
# ------------Dicionário-Geral------------
self.utentes = HashTable()
self.profissionais = HashTable()
self.familias = HashTable()
# ----------------------------------------
# { "Medicina":{ "Duarte" : Obj_Profissional } }
self.categorias = HashTable()
# { "Jovem": { "Duarte" : Obj_Utente } }
self.faixasetarias = HashTable()
# { "Consulta": { "Duarte" : [Obj_Cuidados] } }
self.servicos = HashTable()
self.tad_servicos = HashTable()
self.tad_faixasetarias = HashTable()
self.tad_categorias = HashTable()
# -------------------Tads----------------------
self.tad_categorias.insert("Medicina", 1)
self.tad_categorias.insert("Enfermagem", 2)
self.tad_categorias.insert("Auxiliar", 3)
self.tad_faixasetarias.insert("Jovem", 1)
self.tad_faixasetarias.insert("Adulto", 2)
self.tad_faixasetarias.insert("Idoso", 3)
self.tad_servicos.insert("Consula", 1)
self.tad_servicos.insert("PequenaCirurgia", 2)
self.tad_servicos.insert("Enfermagem", 3)
# ------------------Categorias-----------------
self.categorias.insert("Medicina", HashTable())
self.categorias.insert("Enfermagem", HashTable())
self.categorias.insert("Auxiliar", HashTable())
# -------------------Faixas-Etárias-------------
self.faixasetarias.insert("Adulto", HashTable())
self.faixasetarias.insert("Jovem", HashTable())
self.faixasetarias.insert("Idoso", HashTable())
# ----------------------Servicos-----------------------------
self.servicos.insert("Consulta", HashTable())
self.servicos.insert("PequenaCirurgia", HashTable())
self.servicos.insert("Enfermagem", HashTable())
# Temos de decidir como implementar os servicos.
# --------------------------------Checks-------------------------------------------
# returns true if there´s a professional with that name
def has_professional(self, nome):
return self.profissionais.has_key(nome)
# returns true if there´s a categorua with that name
def has_categoria(self, categoria):
return self.tad_categorias.has_key(categoria)
def has_utente(self,
nome): # returns true if there´s a utente with that name
return self.utentes.has_key(nome)
def has_familia(
self,
NomeFamilia): # returns true if there´s a familia with that name
return self.familias.has_key(NomeFamilia)
# returns true if there´s a Faixa Etária with that name
def has_faixa_etaria(self, FaixaEtaria):
return self.tad_faixasetarias.has_key(FaixaEtaria)
def has_servico(
self, servico): # returns true if there´s a servico with that name
return self.tad_servicos.has_key(servico)
# Returns true if the utente is in a familia
def has_utente_a_familia(self, nome):
utente = self.utentes.get(nome)
return utente.has_familia()
def has_profissionais(
self): # returns true if there´s at least one professional
return self.profissionais.size() != 0
def has_utentes(self): # returns true if there´s at least one utente
return self.utentes.size() != 0
def has_familias(self): # returns true if there´s at least one utente
return self.familias.size() != 0
# returns true if there´s at least one cuidado in utente
def has_utente_any_cuidados(self, nome):
utente = self.utentes.get(nome)
return utente.has_cuidados()
# returns true if there´s at least one cuidado in profissional
def has_profissional_any_cuidados(self, nome):
profissional = self.profissionais.get(nome)
return profissional.has_cuidados()
# returns true if there´s at least one cuidado in utente in the familia
def has_familia_any_cuidados(self, NomFamilia):
familia = self.familias.get(NomFamilia)
return familia.has_cuidados()
# ---------------------------------------Gets-----------------------------------------
def get_utente(self, nome):
return self.utentes.get(nome)
def get_familia(self, NomeFamilia):
return self.familias.get(NomeFamilia)
def get_profissional(self, nome):
return self.profissionais.get(nome)
def get_profissionais_in_categoria(self, categoria):
return self.categorias.get(categoria).keys()
def get_utentes_in_faixa_etaria(self, faixa_etaria):
return self.faixasetarias.get(faixa_etaria).keys()
# ----------------------------------Lists-to-arrays-------------------------------------
def list_to_array(self, SinglyList):
size = SinglyList.size()
it = SinglyList.iterator()
i = 0
result = (size * ctypes.py_object)()
while it.has_next():
result[i] = it.next()
i += 1
return result
# ------------------------------------------------------------------------------------
def registar_profissional(self, categoria, name):
profissional = Profissional(name, categoria)
self.profissionais.insert(name, profissional)
self.categorias.get(categoria).insert(name, profissional)
def registar_utente(self, name, FaixaEtaria):
utente = Utente(name, FaixaEtaria)
self.utentes.insert(name, utente)
self.faixasetarias.get(FaixaEtaria).insert(name, utente)
def registar_familia(self, NomeFamilia):
self.familias.insert(NomeFamilia, Familia(NomeFamilia))
def associar_utente_a_familia(self, nome, NomeFamilia):
familia = self.familias.get(NomeFamilia)
utente = self.utentes.get(nome)
familia.add_member(utente)
utente.set_familia(NomeFamilia)
def desassociar_utente_a_familia(self, nome):
utente = self.utentes.get(nome)
familia = self.familias.get(utente.get_familia())
utente.remove_familia()
familia.remove_member(nome)
def listar_profissionais(self):
# Returns a List [["Medicina","Gilinho"]]
result = SinglyLinkedList()
medicina = self.list_to_array(self.categorias.get("Medicina").keys())
enfermagem = self.list_to_array(
self.categorias.get("Enfermagem").keys())
auxiliar = self.list_to_array(self.categorias.get("Auxiliar").keys())
if self.categorias.get('Medicina').keys().size() != 0:
medicina = Sorting_Algorithm().sort(
medicina,
self.categorias.get('Medicina').keys().size())
result.insert_last(medicina)
if self.categorias.get('Enfermagem').keys().size() != 0:
enfermagem = Sorting_Algorithm().sort(
enfermagem,
self.categorias.get("Enfermagem").keys().size())
result.insert_last(enfermagem)
if self.categorias.get('Auxiliar').keys().size() != 0:
auxiliar = Sorting_Algorithm().sort(
auxiliar,
self.categorias.get("Auxiliar").keys().size())
result.insert_last(auxiliar)
return result
def listar_utentes(self):
# Returns a List[["Gil","Idoso","Gilinho"]]
result = SinglyLinkedList()
jovem = self.list_to_array(self.faixasetarias.get("Jovem").keys())
adulto = self.list_to_array(self.faixasetarias.get("Adulto").keys())
idoso = self.list_to_array(self.faixasetarias.get("Idoso").keys())
if self.faixasetarias.get('Jovem').keys().size() != 0:
jovem = Sorting_Algorithm().sort(
jovem,
self.faixasetarias.get('Jovem').keys().size())
result.insert_last(jovem)
if self.faixasetarias.get('Adulto').keys().size() != 0:
adulto = Sorting_Algorithm().sort(
adulto,
self.faixasetarias.get("Adulto").keys().size())
result.insert_last(adulto)
if self.faixasetarias.get('Idoso').keys().size() != 0:
idoso = Sorting_Algorithm().sort(
idoso,
self.faixasetarias.get("Idoso").keys().size())
result.insert_last(idoso)
return result
def listar_familias(self):
familias = self.list_to_array(self.familias.keys())
Sorting_Algorithm().sort(familias, self.familias.keys().size())
return familias
def mostrar_familia(self, nome_familia):
# Retuns a list [["Jovem","Galinha"],["Idoso","Gilinho"]]
familia = self.get_familia(nome_familia)
result = SinglyLinkedList()
jovem = self.list_to_array(familia.get_jovens())
adulto = self.list_to_array(familia.get_adultos())
idoso = self.list_to_array(familia.get_idosos())
if familia.get_jovens().size() != 0:
jovem = Sorting_Algorithm().sort(jovem,
familia.get_jovens().size())
result.insert_last(jovem)
if familia.get_adultos().size() != 0:
adulto = Sorting_Algorithm().sort(adulto,
familia.get_adultos().size())
result.insert_last(adulto)
if familia.get_idosos().size() != 0:
idoso = Sorting_Algorithm().sort(idoso,
familia.get_idosos().size())
result.insert_last(idoso)
return result
# pega na lista do cli adiciona á aos cuidados do utente, atualiza o profissional(antes de dar add), meter na hash table do profissional com o nome do utente
def marcar_cuidados_a_utente(self, nome, lista_de_cuidados):
utente = self.get_utente(nome)
lista_iterator = lista_de_cuidados.iterator()
while lista_iterator.has_next():
cuidado = lista_iterator.next()
# --------------to-profissional-----------------
profissional = self.get_profissional(cuidado.get_profissional())
profissional.add_to_cuidados(cuidado)
# ---------------to-servicos--------------------
self.add_cuidados_to_servico(cuidado)
# ----------------to-utente---------------------
utente.add_to_cuidados(cuidado)
utente.add_profissional_in(cuidado.get_profissional())
utente.add_servicos_in(cuidado.get_servico())
# ----------------------------------------------
# adds a cuidado to the name of the utente in servico
def add_cuidados_to_servico(self, cuidado):
servico = self.servicos.get(cuidado.get_servico())
utente = cuidado.get_utente()
if not servico.has_key(utente):
servico.insert(utente, SinglyLinkedList())
servico.get(utente).insert_last(cuidado)
def remove_utente_from_servico(self, nome, servico):
servico = self.servicos.get(servico)
servico.remove(nome)
def miga(self):
pass # chama no final a func marcar_cuidados_a_utente
# fazer a func, waiting list que é chamada no cli, e serve como caixote de objetos, cuidados a mandar para mcau.
def get_object_name(self, objct):
return objct.get_name()
def cancelar_cuidados_marcados_a_utente(self, nome):
utente = self.get_utente(nome)
profissionais_in = utente.get_profissionais_in().iterator()
servicos_in = utente.get_servicos_in().iterator()
# -------------------profissionais------------------
while profissionais_in.has_next():
profissional = self.get_profissional(profissionais_in.next())
profissional.remove_utente_from_cuidados(nome)
# -------------------servicos-----------------------
while servicos_in.has_next():
self.remove_utente_from_servico(nome, servicos_in, next())
# --------------------------------------------------
utente.remove_cuidados()
def listar_cuidados_marcados_a_utente(self, nome):
utente = self.controller.get_utente(nome)
return utente.get_cuidados()
pass # Returns a list with objects cuidados
def listar_cuidados_marcados_a_familia(self, NomeFamilia):
pass # Returns a list [["Dudas","Consulta","Medicina","Gilinho"]]
def listar_servicos_marcados_a_profissional(self, Categoria,
NomeProfissional):
pass # returns a list [["Consulta","Dudas"]]
def listar_servicos_marcados_a_profissional(self, categoria,
nome_profissional):
pass # returns a list [["Consulta","Dudas"]]
def listar_marcacoes_por_tipo_de_servico(self, servico):
pass # Returns a list [["Medicina","Gilinho","Dudas"]]
class Controller:
def __init__(self):
# ------------Dicionário-Geral------------
self.utentes = HashTable()
self.profissionais = HashTable()
self.familias = HashTable()
self.tad_servico = HashTable()
# ----------------------------------------
# { "Medicina":{ "Duarte" : Obj_Profissional } }
self.categorias = HashTable()
# { "Jovem": { "Duarte" : Obj_Utente } }
self.faixasetarias = HashTable()
# { "Consulta": { "Duarte" : [Obj_Cuidados] } }
self.servicos = HashTable()
# ------------------Categorias-----------------
self.categorias.insert("Medicina", HashTable())
self.categorias.insert("Enfermagem", HashTable())
self.categorias.insert("Auxiliar", HashTable())
# -------------------Faixas-Etárias-------------
self.faixasetarias.insert("Adulto", HashTable())
self.faixasetarias.insert("Jovem", HashTable())
self.faixasetarias.insert("Idoso", HashTable())
# ----------------------Servicos-----------------------------
self.servicos.insert("Consulta", HashTable())
self.servicos.insert("PequenaCirurgia", HashTable())
self.servicos.insert("Enfermagem", HashTable())
# ----------------------Tad_servico--------------------------
self.tad_servico.insert("Consulta", HashTable())
self.tad_servico.insert("PequenaCirurgia", HashTable())
self.tad_servico.insert("Enfermagem", HashTable())
self.populate_tad_servico()
# --------------------------------Checks-------------------------------------------
# returns true if there´s a professional with that name
def has_professional(self, nome):
return self.profissionais.has_key(nome)
# returns true if there´s a categorua with that name
def has_categoria(self, categoria):
return self.categorias.has_key(categoria)
def has_utente(self, nome): # returns true if there´s a utente with that name
return self.utentes.has_key(nome)
def has_familia(self, NomeFamilia): # returns true if there´s a familia with that name
return self.familias.has_key(NomeFamilia)
# returns true if there´s a Faixa Etária with that name
def has_faixa_etaria(self, FaixaEtaria):
return self.faixasetarias.has_key(FaixaEtaria)
def has_servico(self, servico): # returns true if there´s a servico with that name
return self.servicos.has_key(servico)
# Returns true if the utente is in a familia
def has_utente_a_familia(self, nome):
utente = self.utentes.get(nome)
return utente.has_familia()
def has_profissionais(self): # returns true if there´s at least one professional
return self.profissionais.size() != 0
def has_utentes(self): # returns true if there´s at least one utente
return self.utentes.size() != 0
def has_familias(self): # returns true if there´s at least one utente
return self.familias.size() != 0
# returns true if there´s at least one cuidado in utente
def has_utente_any_cuidados(self, nome):
utente = self.utentes.get(nome)
return utente.has_cuidados()
# returns true if there´s at least one cuidado in profissional
def has_profissional_any_cuidados(self, nome):
profissional = self.profissionais.get(nome)
return profissional.has_cuidados()
# returns true if there´s at least one cuidado in utente in the familia
def servico_has_categoria(self, servico, categoria):
return self.tad_servico.get(servico).has_key(categoria)
def has_familia_any_cuidados(self, NomFamilia):
familia = self.familias.get(NomFamilia)
return familia.has_cuidados()
# ---------------------------------------Gets-----------------------------------------
def get_utente(self, nome):
return self.utentes.get(nome)
def get_familia(self, NomeFamilia):
return self.familias.get(NomeFamilia)
def get_profissional(self, nome):
return self.profissionais.get(nome)
def get_profissionais_in_categoria(self, categoria):
return self.categorias.get(categoria).keys()
def get_utentes_in_faixa_etaria(self, faixa_etaria):
return self.faixasetarias.get(faixa_etaria).keys()
# ----------------------------------Lists-to-arrays-------------------------------------
def list_to_array(self, SinglyList):
size = SinglyList.size()
it = SinglyList.iterator()
i = 0
result = (size * ctypes.py_object)()
while it.has_next():
result[i] = it.next()
i += 1
return result
def populate_tad_servico(self):
self.tad_servico.get("Consulta").insert("Medicina", 1)
self.tad_servico.get("PequenaCirurgia").insert("Medicina", 1)
self.tad_servico.get("PequenaCirurgia").insert("Enfermagem", 2)
self.tad_servico.get("PequenaCirurgia").insert("Auxiliar", 3)
self.tad_servico.get("Enfermagem").insert("Enfermagem", 1)
self.tad_servico.get("Enfermagem").insert("Auxiliar", 2)
# ------------------------------------------------------------------------------------
def registar_profissional(self, categoria, name):
profissional = Profissional(name, categoria)
self.profissionais.insert(name, profissional)
self.categorias.get(categoria).insert(name, profissional)
def registar_utente(self, name, FaixaEtaria):
utente = Utente(name, FaixaEtaria)
self.utentes.insert(name, utente)
self.faixasetarias.get(FaixaEtaria).insert(name, utente)
def registar_familia(self, nome_familia):
self.familias.insert(nome_familia, Familia(nome_familia))
def associar_utente_a_familia(self, nome, nome_familia):
familia = self.familias.get(nome_familia)
utente = self.utentes.get(nome)
familia.add_member(utente)
utente.set_familia(nome_familia)
def desassociar_utente_a_familia(self, nome):
utente = self.utentes.get(nome)
familia = self.familias.get(utente.get_familia())
utente.set_familia(None)
familia.remove_member(utente)
def create_checker(self):
return Checker()
def create_dump(self):
return SinglyLinkedList()
def create_cuidado(self, utente, servico, categoria, profissional):
return Cuidado(utente, servico, categoria, profissional)
def listar_profissionais(self):
# Returns a List [["Medicina","Gilinho"]]
pass
def listar_utentes(self):
pass
def listar_familias(self):
familias = self.list_to_array(self.familias.keys())
Sorting_Algorithm().sort(familias, self.familias.keys().size())
return familias
def mostrar_familia(self, nome_familia):
# Retuns a list [["Jovem","Galinha"],["Idoso","Gilinho"]]
familia = self.get_familia(nome_familia)
result = SinglyLinkedList()
jovem = self.list_to_array(familia.get_jovens())
adulto = self.list_to_array(familia.get_adultos())
idoso = self.list_to_array(familia.get_idosos())
if familia.get_jovens().size() != 0:
jovem = Sorting_Algorithm().sort(
jovem, familia.get_jovens().size())
result.insert_last(jovem)
if familia.get_adultos().size() != 0:
adulto = Sorting_Algorithm().sort(
adulto, familia.get_adultos().size())
result.insert_last(adulto)
if familia.get_idosos().size() != 0:
idoso = Sorting_Algorithm().sort(
idoso, familia.get_idosos().size())
result.insert_last(idoso)
return result
# pega na lista do cli adiciona á aos cuidados do utente, atualiza o profissional(antes de dar add), meter na hash table do profissional com o nome do utente
def marcar_cuidados_a_utente(self, nome, lista_de_cuidados):
return True
#utente = self.get_utente(nome)
#lista_iterator = lista_de_cuidados.iterator()
# while lista_iterator.has_next():
# cuidado = lista_iterator.next()
# # --------------to-profissional-----------------
# profissional = self.get_profissional(cuidado.get_profissional())
# profissional.add_to_cuidados(cuidado)
# # ---------------to-servicos--------------------
# self.add_cuidados_to_servico(cuidado)
# # ----------------to-utente---------------------
# utente.add_to_cuidados(cuidado)
# utente.add_profissional_in(cuidado.get_profissional())
# utente.add_servicos_in(cuidado.get_servico())
# # ----------------------------------------------
# ad#ds a cuidado to the name of the utente in servico
def add_cuidados_to_servico(self, cuidado):
servico = self.servicos.get(cuidado.get_servico())
utente = cuidado.get_utente()
if not servico.has_key(utente):
servico.insert(utente, SinglyLinkedList())
servico.get(utente).insert_last(cuidado)
def remove_utente_from_servico(self, nome, servico):
servico = self.servicos.get(servico)
servico.remove(nome)
def miga(self):
pass # chama no final a func marcar_cuidados_a_utente
# fazer a func, waiting list que é chamada no cli, e serve como caixote de objetos, cuidados a mandar para mcau.
def get_object_name(self, objct):
return objct.get_name()
def cancelar_cuidados_marcados_a_utente(self, nome):
utente = self.get_utente(nome)
profissionais_in = utente.get_profissionais_in().iterator()
servicos_in = utente.get_servicos_in().iterator()
# -------------------profissionais------------------
while profissionais_in.has_next():
profissional = self.get_profissional(profissionais_in.next())
profissional.remove_utente_from_cuidados(nome)
# -------------------servicos-----------------------
while servicos_in.has_next():
self.remove_utente_from_servico(nome, servicos_in, next())
# --------------------------------------------------
utente.remove_cuidados()
def listar_cuidados_marcados_a_utente(self, nome):
utente = self.controller.get_utente(nome)
return utente.get_cuidados()
pass # Returns a list with objects cuidados
def listar_cuidados_marcados_a_familia(self, NomeFamilia):
pass # Returns a list [["Dudas","Consulta","Medicina","Gilinho"]]
def listar_servicos_marcados_a_profissional(self, Categoria, NomeProfissional):
pass # returns a list [["Consulta","Dudas"]]
def listar_servicos_marcados_a_profissional(self, categoria, nome_profissional):
pass # returns a list [["Consulta","Dudas"]]
def listar_marcacoes_por_tipo_de_servico(self, servico):
pass # Returns a list [["Medicina","Gilinho","Dudas"]]
def is_valid_sequence(self, sequence):
arr = self.list_to_array(sequence)
for i in arr:
clear = 0
index = 0
for categoria in arr:
if categoria == "PequenaCirurgia":
if self.check_for_consulta_in_range(arr, 0, index):
clear += 1
if self.check_for_consulta_in_range(arr, index, sequence.size()):
clear -= 1
else:
return False
index += 1
return clear == 0
def check_for_consulta_in_range(self, arr, lower, upper):
for i in range(lower, upper):
if arr[i] == "Consulta":
return True
return False
def give_checker_error(self, checker):
if checker.get('Servico') == True:
return "Serviço inexistente."
elif checker.get('Categoria') == True:
return "Categoria inexistente."
elif checker.get('Profissional') == True:
return "Profissional de saúde inexistente."
elif checker.get('CInvalida') == True:
return "Categoria inválida."
else:
return "Sequência inválida."
def __init__(self):
self.users = HashTable()
def __init__(self, user_name):
self.name = user_name
self.task_lists = HashTable()
class Utente(Pessoa, Tad_Utente):
def __init__(self, nome, Faixa_Etaria):
Pessoa.__init__(self, nome)
self.faixa_etaria = Faixa_Etaria
self.lista_de_cuidados = SinglyLinkedList()
self.familia = None # Sting nome familia
self.profissionais_in = HashTable()
self.serviços_in = HashTable() # todos os serviços dentro de utente
def get_faixa_etaria(self):
return self.faixa_etaria
def get_cuidados(self):
return self.lista_de_cuidados
def add_to_cuidados(self, cuidado):
self.lista_de_cuidados.insert_last(cuidado)
def remove_cuidados(self):
self.lista_de_cuidados.make_empty()
self.remove_profissional_in()
self.remove_serviços_in()
def get_familia(self):
return self.familia
def remove_familia(self):
self.familia = None
def set_familia(self, NomeFamila):
self.familia = NomeFamila
def has_familia(self): # Returns true if the utente is in a familia
if self.get_familia():
return True
return False
def has_cuidados(self):
return self.get_cuidados().is_empty()
def add_to_cuidados(self, cuidado):
self.get_cuidados.insert_last(cuidado)
def get_profissionais_in(self):
return self.profissionais_in.keys(
) # List with all the profissionais in utente
def add_profissional_in(self, nome_profissional):
if not self.profissionais_in.has_key(nome_profissional):
self.profissionais_in.insert(nome_profissional, None)
def remove_profissional_in(self):
profissionais_in = self.profissionais_in.keys().iterator()
while profissionais_in.has_next():
self.profissionais_in.remove(profissionais_in.next())
def get_servicos_in(self):
return self.serviços_in.keys() # List with all the serviços in utente
def add_servicos_in(self, name_serviço):
if not self.serviços_in.has_key(name_serviço):
self.serviços_in.insert(name_serviço, None)
def remove_servicos_in(self):
serviços_in = self.serviços_in.keys().iterator()
while serviços_in.has_next():
self.serviços_in.remove(serviços_in.next())
def __init__(self, nome):
self.nome = nome
self.membros = HashTable()
class TestHashTable(unittest.TestCase):
def setUp(self):
self.table = HashTable(size=11)
def insert_items(self, quantity, shift=0):
for i in range(quantity):
k = f"key_{i+1+shift}"
v = f"value_{i+1+shift}"
self.table.insert(k, v)
def remove_items(self, quantity, shift=0):
for i in range(quantity):
k = f"key_{i+1+shift}"
self.table.remove(k)
def test_size(self):
self.assertEqual(self.table.size(), 0)
self.insert_items(5)
self.assertEqual(self.table.size(), 5)
def test_is_full(self):
self.table = HashTable(size=7)
self.assertFalse(self.table.is_full())
self.insert_items(7)
self.assertTrue(self.table.is_full())
self.remove_items(1)
self.assertFalse(self.table.is_full())
def test_get(self):
with self.assertRaises(NoSuchElementException):
self.table.get("missing_key")
self.insert_items(5)
self.assertEqual(self.table.get("key_3"), "value_3")
with self.assertRaises(NoSuchElementException):
self.table.get("missing_key")
self.remove_items(1, shift=2)
with self.assertRaises(NoSuchElementException):
self.table.get("key_3")
self.insert_items(1, shift=2)
self.assertEqual(self.table.get("key_3"), "value_3")
def test_insert(self):
self.assertFalse(self.table.has_key("key_1"))
self.table.insert("key_1", "value_1")
self.assertTrue(self.table.has_key("key_1"))
with self.assertRaises(DuplicatedKeyException):
self.table.insert("key_1", "value_1")
self.assertEqual(self.table.get("key_1"), "value_1")
def test_update(self):
with self.assertRaises(NoSuchElementException):
self.table.update("key_1", "new_value_1")
self.insert_items(1)
self.assertEqual(self.table.get("key_1"), "value_1")
self.table.update("key_1", "new_value_1")
self.assertEqual(self.table.get("key_1"), "new_value_1")
def test_remove(self):
with self.assertRaises(NoSuchElementException):
self.table.remove("missing_key")
self.insert_items(1)
self.assertEqual(self.table.remove("key_1"), "value_1")
with self.assertRaises(NoSuchElementException):
self.table.remove("key_1")
self.insert_items(5)
self.assertEqual(self.table.remove("key_3"), "value_3")
def test_keys(self):
self.assertEqual(self.table.keys().size(), 0)
self.insert_items(5)
self.assertEqual(self.table.keys().size(), 5)
self.assertNotEqual(self.table.keys().find("key_1"), -1)
def test_values(self):
self.assertEqual(self.table.values().size(), 0)
self.insert_items(5)
self.assertEqual(self.table.values().size(), 5)
self.assertNotEqual(self.table.values().find("value_1"), -1)
def test_items(self):
self.assertEqual(self.table.items().size(), 0)
self.insert_items(5)
self.assertEqual(self.table.items().size(), 5)
it = self.table.items().iterator()
while it.has_next():
item = it.next()
self.assertIn(item.get_key(), [f"key_{i+1}" for i in range(5)])
self.assertIn(item.get_value(), [f"value_{i+1}" for i in range(5)])
def __init__(self):
self.categorias = HashTable()
self.categorias.insert("medicina", HashTable())
self.categorias.insert("enfermagem", HashTable())
self.categorias.insert("auxiliar", HashTable())
class ListController:
def __init__(self):
self.categorias = HashTable()
self.categorias.insert("medicina", HashTable())
self.categorias.insert("enfermagem", HashTable())
self.categorias.insert("auxiliar", HashTable())
def has_categoria(self, nome_categoria):
if self.categorias.has_key(nome_categoria):
return True
return False
def has_profissional(self, nome_categoria, nome_profissional):
categoria = self.categorias.get(nome_categoria)
if categoria.has_key(nome_profissional):
return True
return False
def add_profissional(self, nome_categoria, nome_profissional):
profissionais = self.categorias.get(nome_categoria)
profissional = Profissional(nome_profissional)
profissionais.insert(nome_profissional, profissional)
def has_faixa(self, faixa_etaria):
pass
def has_family(self, nome_familia):
pass
def exist_familia(self, nome_familia):
pass
def remove_user_family(self, nome_utente):
pass
def has_utente_in_table(self):
pass
def print_list_professionals(self):
pass
def print_list_users(self):
pass
def has_family_register(self):
pass
def print_families(self):
pass
def print_users_family(self, nome_familia):
pass
def existe_cuidado(self, nome_utente):
pass
def desmarcar_cuidado(self, nome_utente):
pass
def listar_cuidados_utente(self, nome_utente):
pass
def listar_cuidados_familia(self, nome_familia):
pass
def listar_cuidados_prof(self, nome_profissional):
pass
def has_service(self, serviço):
pass
def has_marked_service(self, serviço):
pass
def list_marked_services(self, serviço):
pass
class Checker():
def __init__(self):
self.checker = HashTable()
self.checker.insert("Servico", False)
self.checker.insert("Categoria", False)
self.checker.insert("Profissional", False)
self.checker.insert("CInvalida", False)
self.checker.insert("SInvalida", False)
def get(self, key):
return self.checker.get(key)
def checks_out(self):
it = self.checker.values().iterator()
while it.has_next():
if it.next():
return False
return True
def change_servico(self):
self.checker.update('Servico', True)
def change_categoria(self):
self.checker.update('Categoria', True)
def change_profissional(self):
self.checker.update(
'Profissional', True)
def change_cinvalida(self):
self.checker.update('CInvalida', True)
def change_sinvalida(self):
self.checker.update('SInvalida', True)
def setUp(self):
self.table = HashTable(size=11)
def __init__(self, nome, categoria):
self.name = nome
self.categoria = categoria
self.lista_de_cuidados = HashTable()