Beispiel #1
0
 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
Beispiel #2
0
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()
Beispiel #3
0
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
Beispiel #4
0
 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())
Beispiel #5
0
    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)
Beispiel #6
0
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())
Beispiel #9
0
 def __init__(self, nome, categoria):
     Pessoa.__init__(self,nome)
     self.categoria=categoria
     self.lista_de_cuidados = HashTable() # Keys=Utentes | Values=List
Beispiel #10
0
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."
Beispiel #12
0
 def __init__(self):
     self.users = HashTable()
Beispiel #13
0
 def __init__(self, user_name):
     self.name = user_name
     self.task_lists = HashTable()
Beispiel #14
0
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())
Beispiel #15
0
 def __init__(self, nome):
     self.nome = nome
     self.membros = HashTable()
Beispiel #16
0
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)])
Beispiel #17
0
 def __init__(self):
     self.categorias = HashTable()
     self.categorias.insert("medicina", HashTable())
     self.categorias.insert("enfermagem", HashTable())
     self.categorias.insert("auxiliar", HashTable())
Beispiel #18
0
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
Beispiel #19
0
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)
Beispiel #20
0
 def setUp(self):
     self.table = HashTable(size=11)
 def __init__(self, nome, categoria):
     self.name = nome
     self.categoria = categoria
     self.lista_de_cuidados = HashTable()