예제 #1
0
class ListaTrabajos:
	def __init__(self):
		self.RT = RepositorioTrabajos()
		self.TrabajoL = self.RT.get_all()

	def nuevo_trabajo(self, cliente, fecha_ingreso, fecha_entrega_propuesta, descripcion):
		#Recibe los datos de un trabajo, crea un nuevo trabajo y lo agrega a la lista Trabajos.
		T = Trabajo(cliente, fecha_ingreso, fecha_entrega_propuesta, None, descripcion,False)
		T.id_trabajo = self.RT.store(T)
		if T.id_trabajo == 0:
			print(T)
			return None
		else:
			self.TrabajoL.append(T)
			return T

	def BuscarPorID(self, id_trabajo):
		#Recibe un ID y retorna un trabajo.
		for T in self.TrabajoL:
			if T.id_trabajo == int(id_trabajo):
				return (T)
		print("El ID ingresado no coincide o pertenece con ningun trabajo asignado")
		return None

	def modificar_trabajo(self, fecha_ingreso, fecha_entrega_propuesta, fecha_entrega_real, descripcion, id_trabajo):
		#Recibe un trabajo y modifica los datos.
		T = self.BuscarPorID(id_trabajo)
		if T:
			T.fecha_ingreso = fecha_ingreso
			T.fecha_entrega_propuesta = fecha_entrega_propuesta
			T.fecha_entrega_real = fecha_entrega_real
			T.descripcion = descripcion
			return self.RT.update(T)
		return None
예제 #2
0
class ListaTrabajos:
    def __init__(self):
        self.rt = RepositorioTrabajos()
        self.lista = self.rt.get_all()

    def nuevo_trabajo(self, cliente, fecha_ingreso, fecha_entrega_propuesta,
                      fecha_entrega_real, descripcion, retirado):
        t = Trabajo(cliente, fecha_ingreso, fecha_entrega_propuesta,
                    fecha_entrega_real, descripcion, retirado)
        t.id_trabajo = self.rt.store(t)
        if t.id_trabajo == 0:
            return None
        else:
            self.lista.append(t)
            return t
예제 #3
0
 def __init__(self):
     self.lista_clientes = ListaClientes()
     self.repositoriocl = RepositorioClientes()
     self.lista = self.repositoriocl.get_all()
     self.repositoriotr = RepositorioTrabajos()
     self.LT = ListaTrabajos()
     self.opciones = {
         "1": self.mostrar_clientes,
         "2": self.nuevo_cliente,
         "3": self.modificar_cliente,
         "4": self.eliminar_cliente,
         "5": self.carga_trabajo,
         "6": self.modificar_trabajo,
         "7": self.mostrar_trabajos,
         "8": self.HistorialTrabajosCl,
         "0": self.salir
     }
예제 #4
0
파일: menu.py 프로젝트: mncasanova/TPFinal
 def __init__(self):
     self.rc = RepositorioClientes()
     self.rt = RepositorioTrabajos()
     self.opciones = {
         "0": self.salir,
         "1": self.mostrar_clientes,
         "2": self.nuevo_cliente,
         "3": self.eliminar_cliente,
         "4": self.modificar_cliente,
         "5": self.nuevo_trabajo,
         "6": self.mostrar_trabajos,
         "7": self.modificar_trabajo,
         "8": self.marcar_finalizado,
         "9": self.marcar_entregado,
         "10": self.eliminar_trabajo,
         "11": self.imprimir_informe
     }
예제 #5
0
 def __init__(self):
     self.repotrabajo = RepositorioTrabajos()
     self.lista_clientes = ListaClientes()
     self.recl = RepositorioClientes()
     self.repo = Repositorio()
     self.listaT = ListaTrabajos()
     self.opciones= {
         "1": self.mostrar_clientes,
         "2": self.nuevo_cliente,
         "3": self.actualizar_datos,
         "4": self.eliminar_cliente,
         "5": self.nuevo_trabajo,
         "6": self.mostrar_trabajo,
         "7": self.modificar_trabajo,
         "8": self.eliminar_trabajo,
         "9": self.generar_informe,
         "0": self.salir
     }
예제 #6
0
class Informe:
    def __init__(self):
        self.rt = RepositorioTrabajos()

    def imprimir_informe(self, id_cliente):
        trabajos = self.rt.get_by_client_id(id_cliente)
        for trabajo in trabajos:
            print("==============================")
            print(trabajo)
            print("==============================")
예제 #7
0
 def __init__(self):
     self.rc = RepositorioClientes()
     self.rt = RepositorioTrabajos()
     self.lista_trabajo = Lista_Trabajo()
     self.lista_clientes = ListaClientes()
     self.opciones = {
         "1": self.mostrar_clientes,
         "2": self.nuevo_cliente,
         "3": self.modificar_particular,
         "4": self.modificar_corporativo,
         "5": self.borrar_cliente,
         "6": self.mostrar_trabajos,
         "7": self.nuevo_trabajo,
         "8": self.trabajo_finalizado,
         "9": self.trabajo_retirado,
         "10": self.modificar_trabajo,
         "11": self.mostrar_no_retirados,
         "12": self.eliminar_trabajo,
         "0": self.salir
     }
예제 #8
0
 def __init__(self):
     self.RC = RepositorioClientes()
     self.RT = RepositorioTrabajos()
     self.ListaC = ListaClientes()
     self.ListaT = ListaTrabajos()
     self.opciones = {
         "1": self.NuevoCliente,
         "2": self.MostrarClientes,
         "3": self.BuscarCliente,
         "4": self.ModificarDatosC,
         "5": self.BorrarCliente,
         "6": self.CargarNuevoT,
         "7": self.MostrarTrabajos,
         "8": self.FinalizarTrabajo,
         "9": self.RetirarTrabajo,
         "10": self.ModificarDatosT,
         "11": self.HistorialTrabajosPorC,
         "12": self.BorrarTrabajo,
         "0": self.salir
     }
예제 #9
0
파일: menu.py 프로젝트: brunoballi/TPFinal
    def __init__(self):
        self.rc = RepositorioClientes()
        self.rt = RepositorioTrabajos()
        self.list_clientes = ListaClientes()
        self.listaTrabajo = ListaTrabajos()
        self.opciones = {
            "1": self.mostrar_clientes,
            "2": self.nuevo_cliente,
            "3": self.buscar_cliente,
            "4": self.modificar_datos_clientes,
            "5": self.borrar_cliente,
            "6": self.nuevo_trabajo,
            "7": self.mostrar_trabajos,
            "8": self.modificar_datos_trabajo,
            "9": self.finalizar_trabajo,
            "10": self.retirar_trabajo,
            "11": self.eliminar_trabajo,
            "12": self.historial_T,

            "0": self.salir
        }
예제 #10
0
 def __init__(self):
     self.lista_clientes = ListaClientes()
     self.reposclientes = RepositorioClientes()
     self.listatrabajos = ListaTrabajos()
     self.repostrabajos = RepositorioTrabajos()
     self.opciones = {
         "1": self.mostrar_clientes,
         "2": self.mostrar_un_cliente,
         "3": self.nuevo_cliente,
         "4": self.actualizar_datos_clientes,
         "5": self.eliminar_clientes,
         "6": self.nuevo_trabajo,
         "7": self.mostrar_trabajo,
         "8": self.trabajo_finalizado,
         "9": self.trabajo_entregado,
         "10": self.actualizar_datos_trabajo,
         "11": self.eliminar_trabajo,
         "12": self.historial_trabajos,
         "13": self.mostrar_trabajos,
         "0": self.salir
     }
예제 #11
0
	def __init__(self):
		self.RT = RepositorioTrabajos()
		self.TrabajoL = self.RT.get_all()
예제 #12
0
class Menu:
    def __init__(self):
        self.rc = RepositorioClientes()
        self.rt = RepositorioTrabajos()
        self.lista_trabajo = Lista_Trabajo()
        self.lista_clientes = ListaClientes()
        self.opciones = {
            "1": self.mostrar_clientes,
            "2": self.nuevo_cliente,
            "3": self.modificar_particular,
            "4": self.modificar_corporativo,
            "5": self.borrar_cliente,
            "6": self.mostrar_trabajos,
            "7": self.nuevo_trabajo,
            "8": self.trabajo_finalizado,
            "9": self.trabajo_retirado,
            "10": self.modificar_trabajo,
            "11": self.mostrar_no_retirados,
            "12": self.eliminar_trabajo,
            "0": self.salir
        }

    def mostrar_menu(self):
        print("""
_________________________________________________
|Menu del sistema:                               |
|1. Mostrar todos los clientes                   |
|2. Agregar Nuevo Cliente                        |
|3. Modificar Cliente PARTICULAR                 |
|4. Modificar Cliente CORPORATIVO                |
|5. Borrar cliente                               |
|6. Mostrar Trabajos                             |
|7. Nuevo Trabajo                                |
|8. Finalizar Trabajo                            |
|9. Marcar trabajo como retirado                 |
|10. Modificar Trabajo                           |
|11. Mostrar trabajos finalizados no retirados   |
|12. Eliminar Trabajo                            |
|0. Salir                                        |
|________________________________________________|
""")

    def ejecutar(self):
        '''Mostrar el menu y responder las opciones'''
        while True:
            self.mostrar_menu()
            opcion = input("Ingrese una opcion: ")
            accion = self.opciones.get(opcion)
            if accion:
                accion()
            else:
                print("{0} no es una opcion valida".format(opcion))

    def mostrar_clientes(self, lista=None):
        if lista == None:
            lista = self.lista_clientes.lista
        print("Clientes: ")
        for cliente in lista:
            print("===========================================")
            print(cliente)
            print("===========================================")

    def nuevo_cliente(self):
        tipo = "A"
        while tipo not in ("C", "c", "P", "p"):
            tipo = input(
                "Ingrese el tipo de cliente: C:corporativo / P:Particular:  ")
        nombre = input("Ingrese el nombre: ")
        if tipo in ("C", "c"):
            contacto = input("ingrese el nombre del contacto: ")
            tc = input("ingrese el telefono del contacto: ")
        else:
            apellido = input("Ingrese el apellido: ")
        tel = input("Ingrese el Telefono: ")
        mail = input("Ingrese el Mail: ")

        if tipo in ("c", "C"):
            c = self.lista_clientes.nuevo_cliente_corporativo(
                nombre, contacto, tc, tel, mail)
        else:
            c = self.lista_clientes.nuevo_cliente_particular(
                nombre, apellido, tel, mail)
        if c is None:
            print("Error al cargar el cliente.")
        else:
            print("Cliente cargado con exito.")

    def modificar_particular(self):
        print("Modificar cliente Particular: ")
        id_cliente = int(input("Ingresa id de un Particular: "))
        obj_cliente = self.rc.get_one_particular(id_cliente)
        print(obj_cliente)
        opcion = int(
            input(""""Elige una opcion para modificar: 
                            1. Nombre
                            2. Apellido
                            3. Teléfono
                            4. Mail
                            0. Salir
                            : """))
        if opcion == 1:
            nuevo_nombre = input("Ingrese el nuevo NOMBRE:")
            obj_cliente.nombre = nuevo_nombre
            print("Nombre cambiado con exito.")

        elif opcion == 2:
            nuevo_apellido = input("Ingrese el nuevo APELLIDO: ")
            obj_cliente.apellido = nuevo_apellido
            print("Apellido cambiado con exito.")

        elif opcion == 3:
            nuevo_telefono = input("Ingrese el nuevo TELEFONO: ")
            obj_cliente.telefono = nuevo_telefono
            print("Telefono cambiado con exito.")

        elif opcion == 4:
            nuevo_mail = input("Ingrese un nuevo MAIL: ")
            obj_cliente.mail = nuevo_mail
            print("Mail cambiado con exito.")
        elif opcion == 0:
            return
        self.rc.update(obj_cliente)
        self.lista_clientes = ListaClientes()

    def modificar_corporativo(self):
        print("Modificar cliente Corporativo: ")
        id_cliente = int(input("Ingresa id de un Corporativo: "))
        obj_cliente = self.rc.get_one_corporativo(id_cliente)
        print(obj_cliente)
        opcion = int(
            input(""""Elige una opcion para modificar: 
                            1. Nombre empresa
                            2. Nombre contacto
                            3. Teléfono de contacto
                            4. Telefono
                            5. Mail
                            0. Salir
                            : """))
        if opcion == 1:
            nuevo_nombre_empresa = input(
                "Ingrese el nuevo NOMBRE DE LA EMPRESA:")
            obj_cliente.nombre_empresa = nuevo_nombre_empresa
            print("Nombre de empresa cambiado con exito.")

        elif opcion == 2:
            nuevo_nombre_contacto = input(
                "Ingrese el nuevo NOMBRE DE CONTACTO:")
            obj_cliente.nombre_contacto = nuevo_nombre_contacto
            print("Nombre de contacto cambiado con exito.")

        elif opcion == 3:
            nuevo_telefono_contacto = input(
                "Ingrese el nuevo TELEFONO DE CONTACTO: ")
            obj_cliente.telefono_contacto = nuevo_telefono_contacto
            print("Telefono de contacto cambiado con exito.")

        elif opcion == 4:
            nuevo_telefono = input("Ingrese el nuevo TELEFONO: ")
            obj_cliente.telefono = nuevo_telefono
            print("Telefono cambiado con exito.")

        elif opcion == 5:
            nuevo_mail = input("Ingrese un nuevo MAIL: ")
            obj_cliente.mail = nuevo_mail
            print("Mail cambiado con exito.")

        elif opcion == 0:
            return

        self.rc.update(obj_cliente)
        self.lista_clientes = ListaClientes()
        print("Cambio Exitoso:")
        print(obj_cliente)

    def borrar_cliente(self):
        lista = self.lista_clientes.lista
        for id_lista in lista:
            print(
                "=================================================================="
            )
            print(id_lista)
            print(
                "=================================================================="
            )
        id_elegido = int(
            input("Ingrese el ID del cliente que quiere eliminar: "))
        for id_lista in lista:
            if id_lista.id_cliente == id_elegido:
                cli = self.lista_clientes.rc.delete(id_lista)
                lista.remove(id_lista)
                print("Se elimino correctamente.")
                break

    def mostrar_trabajos(self, lista=None):
        if lista == None:
            lista = self.lista_trabajo.lista
        for trabajo in lista:
            print("====================================================")
            print("Cliente: ")
            print(trabajo.cliente)
            print("Trabajo: ")
            print("ID: ", trabajo.id_trabajo)
            print("Fecha de entrega: ", trabajo.fecha_entrega_propuesta)
            print("Fecha de entrega real: ", trabajo.fecha_entrega_real)
            print("Descripcion: ", trabajo.descripcion)
            print("Retirado: ", trabajo.retirado)
            print("====================================================")

    def nuevo_trabajo(self):
        obj_cliente = None
        while True:
            cliente = input("Ingrese el id del cliente: ")
            obj_cliente = self.rc.get_one(cliente)
            if obj_cliente != None:
                print(obj_cliente)
                break

        fecha_ingreso = datetime.date.today()
        while True:
            try:
                f = input("Ingrese la fecha propuesta (aaaa,mm,dd): ")
                fecha_propuesta = datetime.datetime.strptime(f, "%Y,%m,%d")
            except ValueError:
                print("Fecha no valida")
                continue
            break
        fecha_entrega_real = None
        descripcion = input("Ingrese la descripcion del trabajo: ")
        retirado = False

        nt = Trabajo(obj_cliente, fecha_ingreso, fecha_propuesta,
                     fecha_entrega_real, descripcion, retirado, None)
        resultado = self.rt.store(nt)
        self.lista_Trabajo = self.rt.get_all()

        print("Trabajo guardado exitosamente. Con el id ", resultado)

    def trabajo_finalizado(self):
        print("Finalizar trabajo: ")
        id_trabajo = int(input("Ingresa id del trabajo: "))
        obj_trabajo = self.rt.get_one(id_trabajo)

        obj_trabajo.fecha_entrega_real = datetime.date.today()
        print("")
        print("Trabajo finalizado con exito: ")
        print("")
        print("==============================================")
        print("ID: ", obj_trabajo.id_trabajo)
        print("Fecha de entrega: ", obj_trabajo.fecha_entrega_propuesta)
        print("Fecha de entrega real: ", obj_trabajo.fecha_entrega_real)
        print("Descripcion: ", obj_trabajo.descripcion)
        print("Retirado: ", obj_trabajo.retirado)
        print("==============================================")

        self.rt.update(obj_trabajo)
        self.lista_trabajo = Lista_Trabajo()

    def trabajo_retirado(self):
        print("Marcar trabajo retirado : ")
        id_trabajo = int(input("Ingresa id del trabajo: "))
        obj_trabajo = self.rt.get_one(id_trabajo)

        obj_trabajo.retirado = True
        print("")
        print("Trabajo retirado con exito: ")
        print("")
        print("==============================================")
        print("ID: ", obj_trabajo.id_trabajo)
        print("Fecha de entrega: ", obj_trabajo.fecha_entrega_propuesta)
        print("Fecha de entrega real: ", obj_trabajo.fecha_entrega_real)
        print("Descripcion: ", obj_trabajo.descripcion)
        print("Retirado: ", obj_trabajo.retirado)
        print("==============================================")

        self.rt.update(obj_trabajo)
        self.lista_trabajo = Lista_Trabajo()

    def modificar_trabajo(self):
        print("Modificar trabajo : ")
        id_trabajo = int(input("Ingresa id del trabajo: "))
        obj_trabajo = self.rt.get_one(id_trabajo)

        while True:
            try:
                f = input("Ingrese la nueva fecha propuesta (aaaa,mm,dd): ")
                fecha_propuesta = datetime.datetime.strptime(f, "%Y,%m,%d")
            except ValueError:
                print("Fecha no valida")
                continue
            break
        descripcion = input("Ingrese la nueva descripcion del trabajo: ")

        obj_trabajo.fecha_entrega_propuesta = fecha_propuesta
        obj_trabajo.descripcion = descripcion

        print("")
        print("Trabajo modificado con exito: ")
        print("")
        print("==============================================")
        print("ID: ", obj_trabajo.id_trabajo)
        print("Fecha de entrega: ", obj_trabajo.fecha_entrega_propuesta)
        print("Fecha de entrega real: ", obj_trabajo.fecha_entrega_real)
        print("Descripcion: ", obj_trabajo.descripcion)
        print("Retirado: ", obj_trabajo.retirado)
        print("==============================================")

        self.rt.update(obj_trabajo)
        self.lista_trabajo = Lista_Trabajo()

    def mostrar_no_retirados(self, lista=None):
        if lista == None:
            lista = self.lista_trabajo.lista
        for trabajo in lista:
            if trabajo.retirado == False and trabajo.fecha_entrega_real != None:
                print("===========================================")
                print("Cliente: ")
                print(trabajo.cliente)
                print("ID: ", trabajo.id_trabajo)
                print("Fecha de entrega: ", trabajo.fecha_entrega_propuesta)
                print("Fecha de entrega real: ", trabajo.fecha_entrega_real)
                print("Descripcion: ", trabajo.descripcion)
                print("Retirado: ", trabajo.retirado)
                print("===========================================")

    def eliminar_trabajo(self):
        id_elegido = int(
            input("Ingrese el ID del trabajo que quiere eliminar: "))
        obj_trabajo = self.rt.get_one(id_elegido)
        resultado = self.rt.delete(obj_trabajo)
        self.lista_trabajo = Lista_Trabajo()
        print("Eliminado: ", resultado)

    def salir(self):
        print("Saliste del programa. Gracias por todo.")
        sys.exit(0)
예제 #13
0
class ListaTrabajos:
    def __init__(self):
        self.rt = RepositorioTrabajos()
        self.listaTrabajo = self.rt.get_all()

    def nuevo_trabajo(self, cliente, fecha_ingreso, fecha_entrega_propuesta,
                      descripcion):
        "Recibe los datos de una trabajo, crea uno nuevo y lo agrega a la lista"
        t = Trabajo(cliente, fecha_ingreso, fecha_entrega_propuesta, None,
                    descripcion, False)
        t.id_trabajo = self.rt.store(t)
        if t.id_trabajo == 0:
            return None
        else:
            self.listaTrabajo.append(t)
            return t

    def _buscar_por_id(self, id_trabajo):
        """Recibe un id de trabajo y retorna el cliente que coincide con esa
        id, o None si ninguno de ellos coincide"""

        for t in self.listaTrabajo:
            if t.id_trabajo == int(id_trabajo):
                return (t)
        return None

    def modificar_datos_trabajo(self, fecha_ingreso, fecha_entrega_propuesta,
                                descripcion, id_trabajo):
        """Recibe un trabajo y modifica sus datos"""
        t = self._buscar_por_id(id_trabajo)
        if t:
            t.fecha_ingreso = fecha_ingreso
            t.fecha_entrega_propuesta = fecha_entrega_propuesta
            t.descripcion = descripcion
            return self.rt.update(t)
        return None

    def trabajo_finalizado(self, id_trabajo):
        """Recibe un trabajo y le modifica la fecha de entrega"""
        t = self._buscar_por_id(id_trabajo)
        if t:
            t.fecha_entrega_real = datetime.date.today()
            return self.rt.update(t)
        return None

    def retiro_trabajo(self, id_trabajo):
        """Recibe un trabajo y modifica el trabajo como retirado"""
        t = self._buscar_por_id(id_trabajo)
        if t:
            if t.fecha_entrega_real == None:
                t.retirado = True
                self.trabajo_finalizado(id_trabajo)
            else:
                t.retirado = True
            return self.rt.update(t)
        return None

    def eliminar_trabajo(self, id_trabajo):
        t = self._buscar_por_id(id_trabajo)
        if t:
            self.rt.delete(t)
            self.listaTrabajo = self.rt.get_all()
            return True
        return None
예제 #14
0
파일: menu.py 프로젝트: mncasanova/TPFinal
class Menu:
    """Mostrar un menú y responder a las opciones"""
    def __init__(self):
        self.rc = RepositorioClientes()
        self.rt = RepositorioTrabajos()
        self.opciones = {
            "0": self.salir,
            "1": self.mostrar_clientes,
            "2": self.nuevo_cliente,
            "3": self.eliminar_cliente,
            "4": self.modificar_cliente,
            "5": self.nuevo_trabajo,
            "6": self.mostrar_trabajos,
            "7": self.modificar_trabajo,
            "8": self.marcar_finalizado,
            "9": self.marcar_entregado,
            "10": self.eliminar_trabajo,
            "11": self.imprimir_informe
        }

    def mostrar_menu(self):
        print("""
Menú del sistema:
0. Salir
1. Mostrar todos los clientes 
2. Ingresar los datos de un nuevo cliente
3. Eliminar cliente
4. Modificar cliente
5. Cargar trabajo nuevo
6. Mostrar todos los trabajos 
7. Modificar trabajo
8. Marcar trabajo como finalizado
9. Marcar trabajo como entregado
10. Eliminar trabajo
11. Imprimir informe de trabajos por cliente
""")

    def ejecutar(self):
        """Mostrar el menu y responder a las opciones."""
        while True:
            self.mostrar_menu()
            opcion = input("Ingresar una opción: ")
            accion = self.opciones.get(opcion)
            if accion:
                accion()
            else:
                print("{0} no es una opción válida".format(opcion))

    def mostrar_clientes(self, lista=None):
        if lista == None:
            lista = ListaClientes().lista
        for Cliente in lista:
            print(Cliente)
            print("==============================")

    def nuevo_cliente(self):
        tipo = "A"
        while tipo not in ("C", "c", "P", "p"):
            tipo = input(
                "Ingrese el tipo de cliente: C:Corporativo / P:Particular")
        nombre = input("Ingrese el nombre: ")
        if tipo in ("C", "c"):
            contacto = input("Ingrese el nombre del contacto: ")
            tc = input("Ingrese el telefono del contacto: ")
        else:
            apellido = input("Ingrese el apellido: ")
        tel = input("Ingrese el telefono: ")
        mail = input("Ingrese el correo electronico: ")
        if tipo in ("C", "c"):
            c = ListaClientes().nuevo_cliente_corporativo(
                nombre, contacto, tc, tel, mail)
        else:
            c = ListaClientes().nuevo_cliente_particular(
                nombre, apellido, tel, mail)

        if c is None:
            print("Error al cargar el cliente")
        else:
            print("Cliente cargado correctamente")

    def eliminar_cliente(self):
        id_cliente = input("Ingrese el ID del cliente: ")
        cliente = self.rc.get_one(id_cliente)
        if cliente is None:
            print("No existe el cliente")

        else:
            cliente_eliminado = self.rc.delete(cliente)
            if cliente_eliminado is True:
                print("El cliente se elimino correctamente")
            else:
                print("No se pudo eliminar")

    def modificar_cliente(self):
        id_cliente = input("Ingrese el ID del cliente: ")
        cliente = self.rc.get_one(id_cliente)
        if cliente is None:
            print("No existe el cliente")
        else:
            print(cliente)
            nuevo_nombre = input("Ingrese el nombre: ")
            cliente.nombre = nuevo_nombre
            if type(cliente).__name__ == "ClienteCorporativo":
                nuevo_contacto = input("Ingrese el nombre del contacto: ")
                cliente.nombre_contacto = nuevo_contacto
                nuevo_tc = input("Ingrese el telefono del contacto: ")
                cliente.telefono_contacto = nuevo_tc
            else:
                nuevo_apellido = input("Ingrese el apellido: ")
                cliente.apellido = nuevo_apellido
                nuevo_tel = input("Ingrese el telefono: ")
                cliente.telefono = nuevo_tel
                nuevo_mail = input("Ingrese el correo electronico: ")
                cliente.mail = nuevo_mail

            cliente_modificado = self.rc.update(cliente)
            if cliente_modificado is True:
                print("El cliente se modifico correctamente")
            else:
                print("No se pudo modificar")

    def nuevo_trabajo(self):
        id_cliente = input("Ingrese el ID del cliente: ")
        cliente = self.rc.get_one(id_cliente)
        if cliente is None:
            print("No existe el cliente")

        else:
            date_entry = input(
                "Ingrese una fecha de ingreso con formato YYYY-MM-DD: ")
            year, month, day = map(int, date_entry.split("-"))
            fecha_ingreso = datetime.date(year, month, day)

            date_entry = input(
                "Ingrese una fecha de entrega propuesta con formato YYYY-MM-DD: "
            )
            year, month, day = map(int, date_entry.split("-"))
            fecha_entrega_propuesta = datetime.date(year, month, day)

            descripcion = input("Ingrese una descripcion para el trabajo: ")
            t = ListaTrabajos().nuevo_trabajo(cliente, fecha_entrega_propuesta,
                                              descripcion, fecha_ingreso)

            if t is None:
                print("Error al cargar el trabajo")
            else:
                print("Trabajo cargado correctamente")

    def mostrar_trabajos(self, lista=None):
        if lista == None:
            lista = ListaTrabajos().lista
        for Trabajos in lista:
            print(Trabajos)
            print("==============================")

    def modificar_trabajo(self):
        id_trabajo = input("Ingrese el ID del trabajo: ")
        trabajo = self.rt.get_one(id_trabajo)
        if trabajo is None:
            print("No existe el trabajo")
        else:
            print(trabajo)
            date_entry = input(
                "Ingrese una nueva fecha de ingreso con formato YYYY-MM-DD: ")
            year, month, day = map(int, date_entry.split("-"))
            fecha_ingreso = datetime.date(year, month, day)

            date_entry = input(
                "Ingrese una nueva fecha de entrega propuesta con formato YYYY-MM-DD: "
            )
            year, month, day = map(int, date_entry.split("-"))
            fecha_entrega_propuesta = datetime.date(year, month, day)

            descripcion = input(
                "Ingrese una nueva descripcion para el trabajo: ")

            trabajo.fecha_ingreso = fecha_ingreso
            trabajo.fecha_entrega_propuesta = fecha_entrega_propuesta
            trabajo.descripcion = descripcion

            finalizado = "A"
            while finalizado not in ("S", "s", "N", "n"):
                finalizado = input("¿Fue finalizado? (S)í / (N)o: ")
            if finalizado in ("S", "s"):
                date_entry = input(
                    "Ingrese la fecha de finalización con formato YYYY-MM-DD: "
                )
                year, month, day = map(int, date_entry.split("-"))
                fecha_entrega = datetime.date(year, month, day)
                trabajo.fecha_entrega_real = fecha_entrega
            else:
                trabajo.fecha_entrega_real = None

            entregado = "A"
            while entregado not in ("S", "s", "N", "n"):
                entregado = input("¿Fue entregado? (S)í / (N)o: ")
            if entregado in ("S", "s"):
                trabajo.retirado = True
            else:
                trabajo.retirado = False

            trabajo_modificado = self.rt.update(trabajo)
            if trabajo_modificado is True:
                print("El trabajo se modifico correctamente")
            else:
                print("No se pudo modificar")

    def marcar_finalizado(self):
        id_trabajo = input("Ingrese el ID del trabajo: ")
        trabajo = self.rt.get_one(id_trabajo)
        if trabajo is None:
            print("No existe el trabajo")
        else:
            trabajo.fecha_entrega_real = datetime.date.today()
            trabajo_modificado = self.rt.update(trabajo)
            if trabajo_modificado is True:
                print("El trabajo se modifico correctamente")
                print("==============================")
                print(trabajo)
            else:
                print("No se pudo modificar")

    def marcar_entregado(self):
        id_trabajo = input("Ingrese el ID del trabajo: ")
        trabajo = self.rt.get_one(id_trabajo)
        if trabajo is None:
            print("No existe el trabajo")
        else:
            trabajo.retirado = True
            trabajo_modificado = self.rt.update(trabajo)
            if trabajo_modificado is True:
                print("El trabajo se modifico correctamente")
                print("==============================")
                print(trabajo)
            else:
                print("No se pudo modificar")

    def eliminar_trabajo(self):
        id_trabajo = input("Ingrese el ID del trabajo: ")
        trabajo = self.rt.get_one(id_trabajo)
        if trabajo is None:
            print("No existe el trabajo")
        else:
            trabajo_eliminado = self.rt.delete(trabajo)
            if trabajo_eliminado is True:
                print("El trabajo se elimino correctamente")
            else:
                print("No se pudo eliminar")

    def imprimir_informe(self):
        id_cliente = input("Ingrese el ID del cliente: ")
        cliente = self.rc.get_one(id_cliente)
        if cliente is None:
            print("No existe el cliente")
        else:
            Informe().imprimir_informe(id_cliente)

    def salir(self):
        print("Gracias por utilizar el sistema.")
        sys.exit(0)
예제 #15
0
 def __init__(self):
     self.rt = RepositorioTrabajos()
     self.listatrabajo = self.rt.get_all()
예제 #16
0
class ListaClientes:
    def __init__(self):
        self.rc = RepositorioClientes()
        self.rt = RepositorioTrabajos()
        self.list_clientes = self.rc.get_all()
        self.listaTrabajo = self.rt.get_all()

    def nuevo_cliente_corporativo(self, nombre, nombre_contacto,
                                  telefono_contacto, telefono, mail):
        """Recibe los datos de un cliente corporativo, crea un nuevo cliente corporativo y lo agrega a lista de clientes"""
        c = ClienteCorporativo(nombre, nombre_contacto, telefono_contacto,
                               telefono, mail)
        c.id_cliente = self.rc.store(c)
        if c.id_cliente == 0:
            return None
        else:
            self.list_clientes.append(c)
            return c

    def nuevo_cliente_particular(self, nombre, apellido, telefono, mail):
        """Recibe los datos de un cliente particular, crea un nuevo cliente particular y lo agrega a la lista de clietes"""
        c = ClienteParticular(nombre, apellido, telefono, mail)
        c.id_cliente = self.rc.store(c)
        if c.id_cliente == 0:
            return None
        else:
            self.list_clientes.append(c)
            return c

    def _buscar_por_id(self, id_cliente):
        """Recibe un id de contacto y retorna el contacto que coincide con esa
        id, o None si ninguno de ellos coincide"""

        for C in self.list_clientes:
            if C.id_cliente == int(id_cliente):
                return (C)
        return None

    def modificar_datos_CP(self, nombre, apellido, telefono, mail, id_cliente):
        """Recibe los datos modificados y actualiza los datos del cliente particular"""
        Cp = self._buscar_por_id(id_cliente)
        if Cp:
            if nombre == '':
                nombre = Cp.nombre
            else:
                Cp.nombre = nombre
            if apellido == '':
                apellido = Cp.apellido
            else:
                Cp.apellido = apellido
            if telefono == '':
                telefono = Cp.telefono
            else:
                Cp.telefono = telefono
            if mail == '':
                mail = Cp.mail
            else:
                Cp.mail = mail
            return self.rc.update(Cp)
        return None

    def modificar_datos_CC(self, nombre_empresa, nombre_contacto,
                           telefono_contacto, telefono, mail, id_cliente):
        """Recibe los datos modificados y actualiza los datos del cliente corporativo"""
        Cc = self._buscar_por_id(id_cliente)
        if Cc:
            if nombre_empresa == '':
                nombre_empresa = Cc.nombre_empresa
            else:
                Cc.nombre_empresa = nombre_empresa
            if nombre_contacto == '':
                nombre_contacto = Cc.nombre_contacto
            else:
                Cc.nombre_contacto = nombre_contacto
            if telefono_contacto == '':
                telefono_contacto = Cc.telefono_contacto
            else:
                Cc.telefono_contacto = telefono_contacto
            if telefono == '':
                telefono = Cc.telefono
            else:
                Cc.telefono = telefono
            if mail == '':
                mail = Cc.mail
            else:
                Cc.mail = mail
            return self.rc.update(Cc)
        return None

    def eliminar_cliente(self, id_cliente):
        """"Recibe el ID de un cliente y lo elimina, en caso de contener trabajos, tambien los elimina"""
        C = self._buscar_por_id(id_cliente)
        for i in self.rt.get_all():
            if i.cliente.id_cliente == id_cliente:
                self.rt.delete(i)
            self.listaTrabajo = self.rt.get_all()
        self.rc.delete(C)
        self.list_clientes = self.rc.get_all()
        return True
예제 #17
0
class Menu:
    "Muestra ocpiones"

    def __init__(self):
        self.RC = RepositorioClientes()
        self.RT = RepositorioTrabajos()
        self.ListaC = ListaClientes()
        self.ListaT = ListaTrabajos()
        self.opciones = {
            "1": self.NuevoCliente,
            "2": self.MostrarClientes,
            "3": self.BuscarCliente,
            "4": self.ModificarDatosC,
            "5": self.BorrarCliente,
            "6": self.CargarNuevoT,
            "7": self.MostrarTrabajos,
            "8": self.FinalizarTrabajo,
            "9": self.RetirarTrabajo,
            "10": self.ModificarDatosT,
            "11": self.HistorialTrabajosPorC,
            "12": self.BorrarTrabajo,
            "0": self.salir
        }

    def MostrarMenu(self):
        print("""                                              ===============
                                               S I S T E M A 
                                              ===============
        MENU CLIENTES:                                                     MENU TRABAJOS:
        
        1. Ingresar un nuevo cliente                                       6. Cargar nuevo trabajo
        
        2. Mostrar todos los clientes                                      7. Mostrar todos los trabajos
        
        3. Buscar un cliente                                               8. Finalizar un trabajo
        
        4. Modificar los datos de un cliente                               9. Retirar un trabajo
        
        5. Borrar un cliente                                               10. Modificar los datos de un trabajo
        
                                                                           11. Historial de trabajos de un cliente
                                                                           
                                                                           12. Borrar un trabajo
                                                                           
        
        0. Salir del sistema
        """)

    def Ejecutar(self):
        "Mostrar y responder opciones"
        while True:
            self.MostrarMenu()
            opcion = input("INGRESA UNA OPCION: ")
            accion = self.opciones.get(opcion)
            if accion:
                accion()
            else:
                print("{0} no es una opcion valida")

    def NuevoCliente(self):
        "Ingresa un nuevo cliente, ya sea corporativo o particular"
        tipo = "N"
        while tipo not in ("C", "c", "P", "p"):
            tipo = input("""
    Escogio la opcion para ingresar un nuevo cliente, por favor elija el tipo de cliente e ingreselo
    
    C: Corporativo
    P: Particular
    
    Ingrese el tipo de cliente: """)
        if tipo in ("C", "c"):
            print(
                "\nA continuacion se pediran los datos correspondientes al nuevo cliente\n"
            )
            NombreEmpresa = input("Ingrese el nombre de la empresa: ")
            NombreContacto = input("Ingrese el nombre del contacto: ")
            TelCont = input("Ingrese el telefono del contacto: ")
        else:
            print(
                "\nA continuacion se pediran los datos correspondientes al nuevo cliente\n"
            )
            Nombre = input("Ingrese el nombre: ")
            Apellido = input("Ingrese el apellido: ")
        Tel = input("Ingrese el telefono: ")
        Mail = input("Ingrese el mail: ")
        if tipo in ("C", "c"):
            C = self.ListaC.NuevoClienteCorp(NombreEmpresa, NombreContacto,
                                             TelCont, Tel, Mail)
        else:
            C = self.ListaC.NuevoClientePart(Nombre, Apellido, Tel, Mail)
        if C is None:
            print("===========================================")
            print("Ocurrio un error al cargar al nuevo cliente")
            print("===========================================")
        else:
            print("\n===========================================")
            print("El clientes fue cargado con exito")
            print("===========================================\n")
            print(C)
            print("===========================================")
        input(
            "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
        )

    def MostrarClientes(self):
        "Muestra todos los clientes"
        c = self.RC.get_all()
        if c:
            l = self.RC.get_all_corporativos()
            print("""         =====================""")
            print("""         CLIENTES CORPORATIVOS""")
            print("""         =====================""")
            if l:
                for i in l:
                    print("========================================")
                    print(i)
                    print("========================================")
            t = self.RC.get_all_particulares()
            print("""         =====================""")
            print("""         CLIENTES PARTICULARES""")
            print("""         =====================""")
            if t:
                for i in t:
                    print("========================================")
                    print(i)
                    print("========================================")
            input(
                "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
            )
        else:
            print(
                "\nActualmente no se encuentra ningun cliente cargado en el sistema"
            )
            input(
                "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
            )

    def BuscarCliente(self):
        "Solicita un ID, busca al cliente con ese ID y lo muestra"
        c = self.RC.get_all()
        if c:
            print("\nEscogio la opcion para buscar un cliente\n")
            while True:
                try:
                    id_cliente = int(
                        input("Ingrese el ID del cliente que desea buscar: "))
                except ValueError:
                    print('Debe ingresar un numero')
                    continue
                break
            C = self.ListaC.BuscarPorID(id_cliente)
            if C == None:
                print(
                    "\n================================================================="
                )
                print(
                    "El ID ingresado no pertenece a ningun cliente cargado actualmente"
                )
                print(
                    "=================================================================\n"
                )
            else:
                print("\n===============================================\n")
                print(C)
                print("=================================================")
            input(
                "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
            )
        else:
            print(
                "\nActualmente no se encuentra ningun cliente particular guardado en el sistema"
            )
            input(
                "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
            )

    def ModificarDatosC(self):
        "Modificar los datos de un cliente, ya sea cliente corporativo o particular"
        tipo = "N"
        while tipo not in ("C", "c", "P", "p"):
            tipo = input("""
    Escogio la opcion para modificar un cliente, por favor elija el tipo de cliente e ingreselo
    
    C: Corporativo
    P: Particular
    
    Ingrese el tipo de cliente que desea modificar: """)
        if tipo in ("C", "c"):
            l = self.RC.get_all_corporativos()
            if l:
                print("\n" "         =====================" "")
                print("""         CLIENTES CORPORATIVOS""")
                print("""         =====================""")
                for I in l:
                    print("========================================\n")
                    print(I)
                    print("========================================\n")
                while True:
                    try:
                        id_cliente = int(input("Ingrese el ID del cliente: "))
                    except ValueError:
                        print('Debe ingresar un numero')
                        continue
                    break
                Cliente = self.ListaC.BuscarPorID(id_cliente)
                if Cliente:
                    print("========================================\n")
                    print(Cliente)
                    print(
                        "================================================================================="
                    )
                    print(
                        "Modifique el campo que desee, de no querer modificar algun campo dejelo vacio"
                    )
                    print(
                        "=================================================================================\n"
                    )
                    NombreEmpresa = input("Ingrese el nombre de la empresa: ")
                    NombreContacto = input("Ingrese el nombre del contacto: ")
                    TelCont = input("Ingrese el telefono del contacto: ")
                    Tel = input("Ingrese el telefono: ")
                    Mail = input("Ingrese el mail: ")
                    C = self.ListaC.ModificarDatosCC(NombreEmpresa,
                                                     NombreContacto, TelCont,
                                                     Tel, Mail, id_cliente)
                    if C == None:
                        print("\n========================================\n")
                        print(
                            "Ocurrio un error al modificar los datos del cliente"
                        )
                        print("========================================\n")
                        input(
                            "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                        )
                    else:
                        print(
                            "\n===============================================================\n"
                        )
                        print("""Los datos del cliente se modificaron con exito
A continuacion se podran ver los datos del cliente actualizados""")
                        print(
                            "\n===============================================================\n"
                        )
                        print("\n========================================")
                        print(Cliente)
                        print("========================================")
                        input(
                            "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                        )
                else:
                    print(
                        "\nEl ID ingresado no pertenece a ningun cliente corporativo guardado en el sistema"
                    )
                    input(
                        "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                    )
            else:
                print(
                    "\nActualmente no se encuentra ningun cliente corporativo guardado en el sistema"
                )
                input(
                    "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                )
        else:
            l = self.RC.get_all_particulares()
            if l:
                print("\n" "         =====================" "")
                print("""         CLIENTES PARTICULARES""")
                print("""         =====================""")
                for I in l:
                    print("========================================\n")
                    print(I)
                    print("========================================\n")
                while True:
                    try:
                        id_cliente = int(input("Ingrese el ID del cliente: "))
                    except ValueError:
                        print('Debe ingresar un numero')
                        continue
                    break
                Cliente = self.ListaC.BuscarPorID(id_cliente)
                if Cliente:
                    print("\n========================================\n")
                    print(Cliente)
                    print("========================================\n")
                    print(
                        "=============================================================================="
                    )
                    print(
                        "Modifique el campo que desee, de no querer modificar algun campo dejelo vacio"
                    )
                    print(
                        "==============================================================================\n"
                    )
                    Nombre = input("Ingrese el nombre: ")
                    Apellido = input("Ingrese el apellido: ")
                    Tel = input("Ingrese el telefono: ")
                    Mail = input("Ingrese el mail: ")
                    C = self.ListaC.ModificarDatosCP(Nombre, Apellido, Tel,
                                                     Mail, id_cliente)
                    if C == None:
                        print(
                            "\n================================================\n"
                        )
                        print(
                            "Ocurrio un error al modificar los datos del cliente"
                        )
                        print(
                            "==================================================\n"
                        )
                        input(
                            "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                        )
                    else:
                        print(
                            "\n===============================================================\n"
                        )
                        print(
                            """Los datos del cliente fueron modificaros con exito
A continuacion se podran ver los datos del cliente actualizados""")
                        print(
                            "\n===============================================================\n"
                        )
                        print("========================================\n")
                        print(Cliente)
                        print("========================================")
                        input(
                            "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                        )
                else:
                    print(
                        "\nEl ID ingresado no pertenece a ningun cliente particular guardado en el sistema"
                    )
                    input(
                        "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                    )
            else:
                print(
                    "\nActualmente no se encuentra ningun cliente particular guardado en el sistema"
                )
                input(
                    "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                )

    def BorrarCliente(self):
        "Solicita un ID y borra al cliente, en caso de que tenga trabajos pendientes, tambien los borra"
        l = self.RC.get_all_corporativos()
        if l:
            print("""         =====================""")
            print("""         CLIENTES CORPORATIVOS""")
            print("""         =====================""")
            for i in l:
                print("========================================")
                print("ID cliente: ", i.id_cliente, "- Nombre: ",
                      i.nombre_empresa)
                print("========================================")
        t = self.RC.get_all_particulares()
        if t:
            print("""         =====================""")
            print("""         CLIENTES PARTICULARES""")
            print("""         =====================""")
            for i in t:
                print("========================================")
                print("ID cliente: ", i.id_cliente, "- Nombre: ", i.nombre)
                print("========================================\n")
        if l or t:
            while True:
                try:
                    id_cliente = int(
                        input("Ingrese el ID del cliente a borrar: "))
                except ValueError:
                    print('Debe ingresar un numero')
                    continue
                break
            D = self.ListaC.BuscarPorID(id_cliente)
            if D:
                print("\n========================================\n")
                print(D)
                print("========================================\n")
                U = "J"
                while U not in ("S", "s", "N", "n"):
                    U = input("""¿Estas seguro que desea eliminar al cliente? 
    
    S: Si borrar al cliente
    N: No borrar al cliente
    
Ingrese una opcion: """)
                if U in ("S", "s"):
                    B = self.ListaC.EliminarCliente(id_cliente)
                    if B == None:
                        print("========================================")
                        print("Ocurrio un error al querer borrar al cliente")
                        print("========================================")
                        input(
                            "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                        )
                    else:
                        print("\n========================================")
                        print("El cliente fue borrado con exito")
                        print("========================================")
                        input(
                            "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                        )

                else:
                    print("\nHa decidido no borrar al cliente")
                    input(
                        "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                    )
            else:
                print(
                    "\nEl ID ingresado no pertenece a ningun cliente guardado en el sistema"
                )
                input(
                    "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                )
        else:
            print(
                "\nActualmente no se encuentra ningun cliente guardado en el sistema"
            )
            input(
                "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
            )

    def CargarNuevoT(self):
        "Solicita el ID de un cliente y carga los datos de un nuevo trabajo"
        l = self.RC.get_all_corporativos()
        if l:
            print("""         =====================""")
            print("""         CLIENTES CORPORATIVOS""")
            print("""         =====================""")
            for i in l:
                print("========================================")
                print("ID cliente: ", i.id_cliente, "- Nombre: ",
                      i.nombre_empresa)
                print("========================================")
        t = self.RC.get_all_particulares()
        if t:
            print("""         =====================""")
            print("""         CLIENTES PARTICULARES""")
            print("""         =====================""")
            for i in t:
                print("========================================")
                print("ID cliente: ", i.id_cliente, "- Nombre: ", i.nombre)
                print("========================================\n")
        if l or t:
            while True:
                try:
                    id_cliente = int(input("Ingrese el ID del cliente: "))
                except ValueError:
                    print('Debe ingresar un numero')
                    continue
                break
            C = self.ListaC.BuscarPorID(id_cliente)
            if C == None:
                print(
                    "\nEl ID ingresado no pertenece a ningun cliente guardado en el sistema"
                )
                input(
                    "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                )
            else:
                fecha_ingreso = date.today()
                print("\nLa fecha de ingreso es: ", fecha_ingreso)
                print("\nA continuacion ingrese la fecha de entrega propuesta")
                while True:
                    try:
                        dia = int(input("Ingrese el dia (1 a 31): "))
                    except ValueError:
                        print('Debe ingresar un numero del 1 al 31')
                        continue
                    break
                while True:
                    try:
                        mes = int(input("Ingrese el mes (1 a 12): "))
                    except ValueError:
                        print('Debe ingresar un numero del 1 al 12')
                        continue
                    break
                while True:
                    try:
                        anio = int(input("Ingrese el año: "))
                    except ValueError:
                        print('Debe ingresar un numero')
                        continue
                    break
                fecha_entrega_propuesta = date(anio, mes, dia)
                descripcion = input(
                    "\nIngrese la descripcion del nuevo trabajo: ")
                T = self.ListaT.NuevoTrabajo(C, fecha_ingreso,
                                             fecha_entrega_propuesta,
                                             descripcion)
                if T == None:
                    print("\n========================================\n")
                    print("Ocurrio un error al cargar el nuevo trabajo")
                    print("========================================")
                    input(
                        "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                    )

                else:
                    print("\n========================================")
                    print("El nuevo trabajo se cargo con exito\n")
                    print(T)
                    print("========================================\n")
                    input(
                        "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                    )
        else:
            print(
                "\nActualmente no se encuentra ningun cliente guardado en el sistema por lo que no se puede cargar un nuevo trabajo"
            )
            input(
                "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
            )

    def MostrarTrabajos(self):
        "Muestra una lista con todos los trabajos"
        Lista = self.RT.get_all()
        if Lista:
            for Cliente in Lista:
                print("\n===========================================\n")
                print(Cliente)
                print("===========================================")
        else:
            print(
                "\nActualmente no se encuentra ningun trabajo cargado en el sistema"
            )
        input(
            "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
        )

    def FinalizarTrabajo(self):
        "Solicita un ID trabajo y modifica la fecha de entrega real"
        t = self.RT.get_all()
        if t:
            for i in t:
                print("========================================")
                print(i.cliente)
                print("ID trabajo: ", i.id_trabajo, "- Fecha entrega real: ",
                      i.fecha_entrega_real)
                print("========================================")
            print("\n========================================")
            while True:
                try:
                    id_trabajo = int(input("Ingrese el ID del trabajo: "))
                except ValueError:
                    print('Debe ingresar un numero')
                    continue
                break
            C = self.ListaT.BuscarPorID(id_trabajo)
            if C == None:
                print(
                    "\nEl ID ingresado no pertenece a ningun trabajo guardado en el sistema"
                )
                input(
                    "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                )
            else:
                if C.fecha_entrega_real:
                    print(
                        "El estado del trabajo ya se encuentra como finalizado"
                    )
                    input(
                        "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                    )
                else:
                    print("\n========================================\n")
                    print(C)
                    print("========================================")
                    tipo = "w"
                    while tipo not in ("S", "s", "N", "n"):
                        print(
                            "============================================================================"
                        )
                        tipo = input(
                            """¿Estas seguro que desea dar por finalizado el trabajo?
                            
    S: Finalizar trabajo
    N: No finalizar
            
    Ingresa una opcion: """)
                        print(
                            "============================================================================"
                        )
                    if tipo in ("S", "s"):
                        T = self.ListaT.TrabajoFinalizado(id_trabajo)
                        if T == None:
                            print(
                                "\n=============================================="
                            )
                            print(
                                "Error al modificar la entrega real del trabajo"
                            )
                            print(
                                "=============================================="
                            )
                            input(
                                "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                            )
                        else:
                            print(
                                "\n===================================================="
                            )
                            print(
                                "\nLa entrega real del trabajo fue modificada con exito"
                            )
                            print(
                                "\n===================================================="
                            )
                            print(C)
                            print(
                                "===================================================="
                            )
                            input(
                                "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                            )
                    else:
                        print(
                            "\n================================================================="
                        )
                        print(
                            "No se realizo ninguna modificacion en la finalizacion del trabajo"
                        )
                        print(
                            "=================================================================\n"
                        )
                        input(
                            "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                        )
        else:
            print(
                "\nActualmente no se encuentra ningun trabajo cargado en el sistema"
            )
            input(
                "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
            )

    def RetirarTrabajo(self):
        "Solicita un ID trabajo y lo marca como retirado"
        t = self.RT.get_all()
        if t:
            for i in t:
                print("\n========================================")
                print(i.cliente)
                print("ID trabajo: ", i.id_trabajo, "- Retirado: ", i.retirado)
                print("=========================================\n")
            while True:
                try:
                    id_trabajo = int(input("Ingrese el ID del trabajo: "))
                except ValueError:
                    print('Debe ingresar un numero')
                    continue
                break
            C = self.ListaT.BuscarPorID(id_trabajo)
            if C == None:
                print(
                    "\nEl ID ingresado no pertenece a ningun trabajo guardado en el sistema"
                )
                input(
                    "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                )
            else:
                if C.retirado == True:
                    print(
                        "\nEl estado del trabajo ya se encuntra como retirado")
                    input(
                        "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                    )
                else:
                    print("\n========================================")
                    print(C)
                    print("========================================")
                    tipo = "w"
                    while tipo not in ("S", "s", "N", "n"):
                        print(
                            "\n======================================================"
                        )
                        tipo = input(
                            """¿Estas seguro que desea dar por finalizado el trabajo?
                        
    S: Retirar el trabajo
    N: No retirar el trabajo
        
    Ingresa una opcion: """)
                        print(
                            "======================================================"
                        )
                    if tipo in ("s", "S"):
                        T = self.ListaT.Trabajo_retirado(id_trabajo)
                        if T == None:
                            print("========================================")
                            print("Error al retirar el trabajo")
                            print("========================================")
                            input(
                                "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                            )
                        else:
                            print("\n========================================")
                            print("El trabajo fue retirado con exito")
                            print("========================================\n")
                            print(C)
                            print("\n========================================")
                            input(
                                "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                            )
                    else:
                        print(
                            "\n==========================================================="
                        )
                        print(
                            "No se realizo ninguna modificacion en el retiro del trabajo"
                        )
                        print(
                            "==========================================================="
                        )
                        input(
                            "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                        )
        else:
            print(
                "\nActualmente no se encuentra ningun trabajo cargado en el sistema"
            )
            input(
                "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
            )

    def ModificarDatosT(self):
        "Solicita un ID trabajo y modifica los datos del trabajo"
        t = self.RT.get_all()
        if t:
            for i in t:
                print("\n========================================")
                print("ID trabajo: ", i.id_trabajo)
                print("Fecha de ingreso: ", i.fecha_ingreso)
                print("Fecha entrega propuesta: ", i.fecha_entrega_propuesta)
                print("Descripcion: ", i.descripcion)
                print("========================================\n")
            while True:
                try:
                    id_trabajo = int(input("Ingrese el ID del trabajo: "))
                except ValueError:
                    print('Debe ingresar un numero')
                    continue
                break
            C = self.ListaT.BuscarPorID(id_trabajo)
            if C == None:
                print(
                    "\nEl ID ingresado no pertenece a ningun trabajo guardado en el sistema"
                )
                input(
                    "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                )
            else:
                print("\n=========================================")
                print(C.cliente)
                print("Trabajo:")
                print("Fecha de ingreso: ", C.fecha_ingreso)
                print("Fecha entrega propuesta: ", C.fecha_entrega_propuesta)
                print("Descripcion: ", C.descripcion)
                print(
                    "\n============================================================================="
                )
                print(
                    "Modifique el campo que desee, de no querer modificar algun campo dejelo vacio"
                )
                print(
                    "============================================================================="
                )
                tipo = "n"
                while tipo not in ("I", "i", "P", "p", "D", "d", "C", "c"):
                    while tipo not in ("C", "c"):
                        tipo = input(
                            """\n¿Estas seguro que desea hacer alguna modificacion?
                        
    I: Fecha de ingreso
    P: Fecha entrega propuesta
    D: Descripcion
    C: No deseo realizar una modificacion
    
    Ingrese una opcion: """)
                        if tipo in ("I", "i"):
                            print("==========================")
                            print("Modificar fecha de ingreso\n")
                            while True:
                                try:
                                    dia = int(
                                        input("Ingrese el dia (1 a 31): "))
                                except ValueError:
                                    print(
                                        'Debe ingresar un numero del 1 al 31')
                                    continue
                                break
                            while True:
                                try:
                                    mes = int(
                                        input("Ingrese el mes (1 a 12): "))
                                except ValueError:
                                    print(
                                        'Debe ingresar un numero del 1 al 12')
                                    continue
                                break
                            while True:
                                try:
                                    anio = int(input("Ingrese el año: "))
                                except ValueError:
                                    print('Debe ingresar un numero')
                                    continue
                                break
                            FechaIngreso = date(anio, mes, dia)
                            T = self.ListaT.ModificarDatosT(
                                FechaIngreso, C.fecha_entrega_real,
                                C.descripcion, id_trabajo)
                            if T == None:
                                print(
                                    "========================================="
                                )
                                print("Error al modificar el trabajo")
                                print(
                                    "========================================="
                                )
                                input(
                                    "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                                )
                            else:
                                print(
                                    "\n========================================="
                                )
                                print(
                                    "Los datos que decidio modificar se modificaron con exito"
                                )
                                print(
                                    "=========================================\n"
                                )
                                print(C)
                                print(
                                    "========================================="
                                )
                        if tipo in ("P", "p"):
                            print("=====================================")
                            print("Modificar fecha de entregra propuesta\n")
                            while True:
                                try:
                                    dia = int(
                                        input("Ingrese el dia (1 a 31): "))
                                except ValueError:
                                    print(
                                        'Debe ingresar un numero del 1 al 31')
                                    continue
                                break
                            while True:
                                try:
                                    mes = int(
                                        input("Ingrese el mes (1 a 12): "))
                                except ValueError:
                                    print(
                                        'Debe ingresar un numero del 1 al 12')
                                    continue
                                break
                            while True:
                                try:
                                    anio = int(input("Ingrese el año: "))
                                except ValueError:
                                    print('Debe ingresar un numero')
                                    continue
                                break
                            FechaEntregaPropuesta = date(anio, mes, dia)
                            T = self.ListaT.ModificarDatosT(
                                C.fecha_ingreso, FechaEntregaPropuesta,
                                C.descripcion, id_trabajo)
                            if T == None:
                                print(
                                    "========================================="
                                )
                                print("Error al modificar el trabajo")
                                print(
                                    "========================================="
                                )
                                input(
                                    "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                                )
                            else:
                                print(
                                    "\n========================================="
                                )
                                print(
                                    "Los datos que decidio modificar se modificaron con exito"
                                )
                                print(
                                    "=========================================\n"
                                )
                                print(C)
                                print(
                                    "========================================="
                                )
                        if tipo in ("D", "d"):
                            print("====================================")
                            print("Modificar la descripcion del trabajo\n")
                            Descripcion = input(
                                "Ingrese la descripcion del trabajo: ")
                            T = self.ListaT.ModificarDatosT(
                                C.fecha_ingreso, C.fecha_entrega_real,
                                Descripcion, id_trabajo)
                            if T == None:
                                print(
                                    "========================================="
                                )
                                print("Error al modificar el trabajo")
                                print(
                                    "========================================="
                                )
                                input(
                                    "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                                )
                            else:
                                print(
                                    "\n========================================="
                                )
                                print(
                                    "Los datos que decidio modificar se modificaron con exito"
                                )
                                print(
                                    "=========================================\n"
                                )
                                print(C)
                                print(
                                    "========================================="
                                )
                    if tipo in ("C", "c"):
                        self.Ejecutar()
        else:
            print(
                "\nActualmente no se encuentra ningun trabajo cargado en el sistema"
            )
            input(
                "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
            )

    def BorrarTrabajo(self):
        "Solicita un ID trabajo y borra un trabajo"
        t = self.RT.get_all()
        if t:
            for i in t:
                print("\n========================================")
                print("ID trabajo: ", i.id_trabajo)
                print("Fecha de ingreso: ", i.fecha_ingreso)
                print("Fecha entrega propuesta: ", i.fecha_entrega_propuesta)
                print("Fecha de entrega real: ", i.fecha_entrega_real)
                print("Descripcion: ", i.descripcion)
                print("Retirado: ", i.retirado)
                print("=========================================\n")
            while True:
                try:
                    id_trabajo = int(input("Ingrese el ID del trabajo: "))
                except ValueError:
                    print('Debe ingresar un numero')
                    continue
                break
            C = self.ListaT.BuscarPorID(id_trabajo)
            if C == None:
                print(
                    "\nEl ID ingresado no pertenece a ningun trabajo guardado en el sistema"
                )
                input(
                    "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                )
            else:
                print("\n=========================================")
                print(C)
                print("=========================================\n")
                tipo = "w"
                while tipo not in ("S", "s", "N", "n"):
                    tipo = input(
                        """¿Estas seguro que desea eliminar el trabajo?
                    
    S: Eliminar trabajo
    N: No eliminar trabajo
    
    Ingresa una opcion: """)
                if tipo in ("S", "s"):
                    T = self.ListaT.EliminarTrabajo(id_trabajo)
                    if T == None:
                        print("=========================================")
                        print("Ocurrio un error al eliminar el trabajo")
                        print("=========================================")
                        input(
                            "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                        )

                    else:
                        print("\n=========================================")
                        print("El trabajo fue eliminado con exito")
                        print("=========================================")
                        input(
                            "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                        )
                else:
                    print("\n==================================")
                    print("Ha decidido no eliminar el trabajo")
                    print("==================================")
                    input(
                        "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                    )
        else:
            print(
                "\nActualmente no se encuentra ningun trabajo cargado en el sistema"
            )
            input(
                "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
            )

    def HistorialTrabajosPorC(self):
        """Solicita un ID y muestra una lista con los trabajos encargados por el cliente"""
        l = self.RC.get_all_corporativos()
        if l:
            print("""         =====================""")
            print("""         CLIENTES CORPORATIVOS""")
            print("""         =====================""")
            for i in l:
                print("========================================")
                print("ID cliente: ", i.id_cliente, "- Nombre: ",
                      i.nombre_empresa)
                print("========================================")
        t = self.RC.get_all_particulares()
        if t:
            print("""         =====================""")
            print("""         CLIENTES PARTICULARES""")
            print("""         =====================""")
            for i in t:
                print("========================================")
                print("ID cliente: ", i.id_cliente, "- Nombre: ", i.nombre)
                print("========================================\n")
        if l or t:
            while True:
                try:
                    id = int(input("\nIngrese el ID del cliente: "))
                except ValueError:
                    print('Debe ingresar un numero')
                    continue
                break
            C = self.ListaC.BuscarPorID(id)
            if C == None:
                print(
                    "\nEl ID ingresado no pertenece a ningun cliente guardado en el sistema"
                )
                input(
                    "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                )
            else:
                print("\n========================================\n")
                print(C)
                print("========================================")
                t = self.ListaT.TrabajoL
                if t:
                    for I in t:
                        if I.cliente.id_cliente == id:
                            print("========================================\n")
                            print("ID trabajo: ", I.id_trabajo)
                            print("Fecha de ingreso: ", I.fecha_ingreso)
                            print("Fecha entrega propuesta: ",
                                  I.fecha_entrega_propuesta)
                            print("Fecha entrega real: ", I.fecha_entrega_real)
                            print("Descripcion: ", I.descripcion)
                            print("Retirado: ", I.retirado)
                            print("========================================")
                    input(
                        "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                    )
                else:
                    print(
                        "\nActualmente el cliente no cuenta con ningun trabajo cargado en el sistema"
                    )
                    input(
                        "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
                    )
        else:
            print(
                "\nActualmente no se encuentra ningun cliente cargado en el sistema"
            )
            input(
                "\nPRESIONE CUALQUIER TECLA PARA VOLVER AL MENU PRINCIPAL DEL SISTEMA"
            )

    def salir(self):
        print("Muchas gracias por haber utilizado el sistema")
        sys.exit(0)
예제 #18
0
class Lista_Trabajo:
    def __init__(self):
        self.rt = RepositorioTrabajos()
        self.lista = self.rt.get_all()
예제 #19
0
class Menu:
    '''Mostrar un menu y responder a las opciones'''
    def __init__(self):
        self.lista_clientes = ListaClientes()
        self.reposclientes = RepositorioClientes()
        self.listatrabajos = ListaTrabajos()
        self.repostrabajos = RepositorioTrabajos()
        self.opciones = {
            "1": self.mostrar_clientes,
            "2": self.mostrar_un_cliente,
            "3": self.nuevo_cliente,
            "4": self.actualizar_datos_clientes,
            "5": self.eliminar_clientes,
            "6": self.nuevo_trabajo,
            "7": self.mostrar_trabajo,
            "8": self.trabajo_finalizado,
            "9": self.trabajo_entregado,
            "10": self.actualizar_datos_trabajo,
            "11": self.eliminar_trabajo,
            "12": self.historial_trabajos,
            "13": self.mostrar_trabajos,
            "0": self.salir
        }

    def mostrar_menu(self):
        print("""
        Menu del sistema:
        1. Mostrar todos los clientes
        2. Mostrar un cliente por ID
        3. Ingresar los datos de un nuevo cliente
        4. Actualizar datos de un cliente
        5. Eliminar cliente
        6. Ingresar los datos de un nuevo trabajo
        7. Mostrar trabajo por ID
        8. Marcar un trabajo como finalizado
        9. Marcar un trabajo como entregado
        10. Actualizar datos de un trabajo
        11. Eliminar trabajo
        12. Historial de trabajos de un cliente
        13. Mostrar todos los trabajos
        0. Salir
        """)

    def ejecutar(self):
        '''Mostrar el menu y responder a las opciones'''
        while True:
            self.mostrar_menu()
            opcion = input("Ingresar una opcion: ")
            accion = self.opciones.get(opcion)
            if accion:
                accion()
            else:
                print("{0} no es una opcion valida".format(opcion))

    #READ - Metodo para mostrar todos los clientes cargados en la base de datos
    def mostrar_clientes(self, lista=None):
        if lista == None:
            lista = self.lista_clientes.lista
        for cliente in lista:
            print(cliente)
            print("***********************************")

    #READ - Metodo para mostrar un solo cliente de la base de datos, buscando por ID
    def mostrar_un_cliente(self, lista=None):
        id_cliente = int(input("Ingrese el id del cliente: "))
        cliente = self.reposclientes.get_one(id_cliente)
        if cliente == None:
            print("Error, no existe un cliente con el ID ingresado")
        else:
            print(cliente)

    #CREATE - Metodo para crear un nuevo objeto cliente en la base de datos, dentro de la clase hija que corresponde (C o P)
    def nuevo_cliente(self):
        tipo = "A"
        while tipo not in ("C", "c", "P", "p"):
            tipo = input(
                "Ingrese el tipo de cliente: C = Corporativo - P = Particular: "
            )
        nombre = input("Ingrese el nombre: ")
        if tipo in ("C", "c"):
            contacto = input("Ingrese el nombre del contacto: ")
            tc = input("Ingrese el telefono del contacto: ")
        else:
            apellido = input("Ingrese el apellido: ")
        tel = input("Ingrese el telefono: ")
        mail = input("Ingrese el correo electronico: ")
        if tipo in ("C", "c"):
            c = self.lista_clientes.nuevo_cliente_corporativo(
                nombre, contacto, tc, tel, mail)
        else:
            c = self.lista_clientes.nuevo_cliente_particular(
                nombre, apellido, tel, mail)
        if c is None:
            print("Error al cargar el cliente")
        else:
            print("Cliente cargado correctamente")

    #UPDATE - Metodo para modificar y actualizar los datos de un cliente particular o corporativo, en la base de datos.
    def actualizar_datos_clientes(self):
        id = int(input("Ingrese el id del cliente: "))
        tipo = "A"
        while tipo not in ("C", "c", "P", "p"):
            tipo = input(
                "Ingrese el tipo de cliente: C = Corporativo - P = Particular: "
            )
        nombre = input("Ingrese el nuevo nombre: ")
        if tipo in ("C", "c"):
            contacto = input("Ingrese el nuevo nombre del contacto: ")
            tc = input("Ingrese el telefono del contacto: ")
        else:
            apellido = input("Ingrese el nuevo apellido: ")
        tel = input("Ingrese el nuevo telefono: ")
        mail = input("Ingrese el nuevo correo electronico: ")
        if tipo in ("C", "c"):
            cliente = ClienteCorporativo(nombre, contacto, tc, tel, mail, id)
            c = self.reposclientes.update(cliente)
        else:
            cliente = ClienteParticular(nombre, apellido, tel, mail, id)
            c = self.reposclientes.update(cliente)
        if c is False:
            print(
                "Error al intentar modificar al cliente, no existe en la lista que corresponde al tipo seleccionado (C o P)"
            )
        else:
            print("Cliente modificado correctamente")

    #DELETE - Metodo para eliminar definitivamente un cliente particular o corporativo, de la base de datos.
    def eliminar_clientes(self, lista=None):
        tipo = "A"
        while tipo not in ("C", "c", "P", "p"):
            tipo = input(
                "Ingrese el tipo de cliente que desea eliminar: C = Corporativo - P = Particular: "
            )
        nombre = None
        if tipo in ("C", "c"):
            id = int(input("Ingrese el id del cliente que desea eliminar: "))
            contacto = None
            tc = None
        else:
            id = int(input("Ingrese el id del cliente que desea eliminar: "))
            apellido = None
        tel = None
        mail = None
        if tipo in ("C", "c"):
            cliente = ClienteCorporativo(nombre, contacto, tc, tel, mail, id)
            c = self.reposclientes.delete(cliente)
        else:
            cliente = ClienteParticular(nombre, apellido, tel, mail, id)
            c = self.reposclientes.delete(cliente)
        if c is False:
            print("Error al intentar eliminar al cliente de la base de datos")
        else:
            print("Cliente eliminado correctamente de la base de datos")

    #NUEVO TRABAJO: Para cargar un nuevo trabajo en base de datos trabajo
    def nuevo_trabajo(self):
        tipo = "A"
        while tipo not in ("C", "c", "P", "p"):
            tipo = input(
                "Ingrese el tipo de cliente al que desa asignarle el trabajo: C = Corporativo - P = Particular: "
            )
        nombre = None
        if tipo in ("C", "c"):
            id = int(input("Ingrese el id del cliente: "))
            contacto = None
            tc = None
        else:
            id = int(input("Ingrese el id del cliente: "))
            apellido = None
        tel = None
        mail = None
        if tipo in ("C", "c"):
            cliente = ClienteCorporativo(nombre, contacto, tc, tel, mail, id)
            fecha_ingreso = datetime.date.today()
            print("Fecha de entrega propuesta: ")
            dia = (int(input("Ingrese el dia de entrega propuesta: ")))
            mes = (int(input("Ingrese el mes de entrega propuesta: ")))
            anio = (int(input("Ingrese el año de entrega propuesta: ")))
            fecha_entrega_propuesta = datetime.date(anio, mes, dia)
            fecha_entrega_real = None
            retirado = False
            descripcion = input(
                "Ingrese una breve descripcion del trabajo a realizar: ")
            nt = self.listatrabajos.nuevo_trabajo(cliente, fecha_ingreso,
                                                  fecha_entrega_propuesta,
                                                  fecha_entrega_real,
                                                  descripcion, retirado)
        else:
            cliente = ClienteParticular(nombre, apellido, tel, mail, id)
            fecha_ingreso = datetime.date.today()
            print("Fecha de entrega propuesta: ")
            dia = (int(input("Ingrese el dia de entrega propuesta: ")))
            mes = (int(input("Ingrese el mes de entrega propuesta: ")))
            anio = (int(input("Ingrese el año de entrega propuesta: ")))
            fecha_entrega_propuesta = datetime.date(anio, mes, dia)
            fecha_entrega_real = None
            retirado = False
            descripcion = input(
                "Ingrese una breve descripcion del trabajo a realizar: ")
            nt = self.listatrabajos.nuevo_trabajo(cliente, fecha_ingreso,
                                                  fecha_entrega_propuesta,
                                                  fecha_entrega_real,
                                                  descripcion, retirado)
        if nt == 0:
            print("Error al intentar cargar el trabajo nuevo")
        else:
            print("Trabajo cargado exitosamente")

    #Mostrar un trabajo en particular
    def mostrar_trabajo(self):
        id_trabajo = int(input("Ingrese el id del trabajo: "))
        trabajo = self.repostrabajos.get_one(id_trabajo)
        if trabajo == None:
            print("Error, no existe un trabajo con el ID ingresado")
        else:
            print(trabajo)

    #TRABAJO FINALIZADO: Para marcar un trabajo como finalizado con la fecha actual (hoy)
    def trabajo_finalizado(self):
        id_trabajo = int(
            input(
                "Ingrese el id del trabajo que desea marcar como concluido: "))
        trabajo = self.repostrabajos.get_one(id_trabajo)
        if trabajo == None:
            print("Error, no existe un trabajo con el ID ingresado")
        else:
            trabajo.fecha_entrega_real = datetime.date.today()
            return self.repostrabajos.update(trabajo)
            print("El trabajo fue marcado como finalizado, de manera exitosa")

    #TRABAJO ENTREGADO: Para marcar un trabajo como entregado
    def trabajo_entregado(self):
        id_trabajo = int(
            input(
                "Ingrese el id del trabajo que desea marcar como entregado: "))
        trabajo = self.repostrabajos.get_one(id_trabajo)
        if trabajo == None:
            print("Error, no existe un trabajo con el ID ingresado")
        else:
            trabajo.retirado = True
            return self.repostrabajos.update(trabajo)
            print("El trabajo fue marcado como entregado, de manera exitosa")

    #ACTUALIZAR TRABAJO: Para actualizar cualquiera de los datos del trabajo
    #(excepto id, y cliente asociado al mismo), buscando por ID
    def actualizar_datos_trabajo(self):
        id_trabajo = int(
            input("Ingrese el id del trabajo que desea actualizar: "))
        trabajo = self.repostrabajos.get_one(id_trabajo)
        if trabajo == None:
            print("Error, no existe un trabajo con el ID ingresado")
        else:
            preg_uno = int(
                input(
                    "Si desea actualizar la fecha de ingreso marque 1, de lo contrario otro numero: "
                ))
            if preg_uno == 1:
                print("Actualizar la fecha de ingreso: ")
                dia = (int(input("Ingrese el dia de ingreso: ")))
                mes = (int(input("Ingrese el mes de ingreso: ")))
                anio = (int(input("Ingrese el año de ingreso: ")))
                fecha_ingreso = datetime.date(anio, mes, dia)
                trabajo.fecha_ingreso = fecha_ingreso
            preg_dos = int(
                input(
                    "Si desea actualizar la fecha de entrega propuesta marque 1, \n de lo contrario otro numero: "
                ))
            if preg_dos == 1:
                print("Actualizar la fecha de entrega propuesta: ")
                dia = (int(input("Ingrese el dia de entrega propuesta: ")))
                mes = (int(input("Ingrese el mes de entrega propuesta: ")))
                anio = (int(input("Ingrese el año de entrega propuesta: ")))
                fecha_entrega_propuesta = datetime.date(anio, mes, dia)
                trabajo.fecha_entrega_propuesta = fecha_entrega_propuesta
            preg_tres = int(
                input(
                    "Si el trabajo ya fue entregado, y desea modificar esa fecha, marque 1,\n de lo contrario marque otro numero: "
                ))
            if preg_tres == 1:
                print("Actualizar la fecha de entrega real: ")
                dia = (int(input("Ingrese el dia de entrega real: ")))
                mes = (int(input("Ingrese el mes de entrega real: ")))
                anio = (int(input("Ingrese el año de entrega real: ")))
                fecha_entrega_real = datetime.date(anio, mes, dia)
                trabajo.fecha_entrega_real = fecha_entrega_real
            preg_cuatro = int(
                input(
                    "Si desea modificar la descripcion del trabajo, marque 1,\n de lo contrario otro numero: "
                ))
            if preg_cuatro == 1:
                print("Actualizar descripcion del trabajo: ")
                descripcion = input(
                    "Ingrese una breve descripcion del trabajo a realizar: ")
                trabajo.descripcion = descripcion
            preg_cinco = int(
                input(
                    "Si desea modificar el estado a retirado/no retirado,\n marque 1, de lo contrario otro numero: "
                ))
            if preg_cinco == 1:
                preg_retirado = int(
                    input(
                        "Ingrese 1 para indicar que el trabajo esta retirado,\n otro numero para marcar como no retirado: "
                    ))
                if preg_retirado == 1:
                    retirado = True
                else:
                    retirado = False
            return self.repostrabajos.update(trabajo)
        print("Datos del trabajo actualizados con exito !!!")

    #ELIMINAR TRABAJO: busca por ID, en repositorio trabajos y si lo encuentra lo elimina de la base de datos
    def eliminar_trabajo(self):
        id_trabajo = int(
            input("Ingrese el id del trabajo que desea eliminar: "))
        trabajo = self.repostrabajos.get_one(id_trabajo)
        if trabajo == None:
            print("Error, no existe un trabajo con el ID ingresado")
        else:
            return self.repostrabajos.delete(trabajo)
            print("Trabajo eliminado con exito !!!")

    #INFORME: Historial de trabajos de un cliente, buscado por su id
    def historial_trabajos(self):
        id_cliente = int(input("Ingrese el ID del cliente: "))
        cliente = self.reposclientes.get_one(id_cliente)
        lista = self.listatrabajos.lista
        for consulta in lista:
            if consulta.cliente.id_cliente == id_cliente:
                print("Trabajo del cliente: ")
                print(consulta)

    #Mostrar todos los trabajos de la base de datos
    def mostrar_trabajos(self, lista=None):
        if lista == None:
            lista = self.listatrabajos.lista
        for cliente in lista:
            print(cliente)
            print("***********************************")

    def salir(self):
        print("Gracias por utilizar el sistema.")
        sys.exit(0)
예제 #20
0
class Menu:
    '''Mostrar un menú y responder a las opciones'''
    def __init__(self):
        self.repotrabajo = RepositorioTrabajos()
        self.lista_clientes = ListaClientes()
        self.recl = RepositorioClientes()
        self.repo = Repositorio()
        self.listaT = ListaTrabajos()
        self.opciones= {
            "1": self.mostrar_clientes,
            "2": self.nuevo_cliente,
            "3": self.actualizar_datos,
            "4": self.eliminar_cliente,
            "5": self.nuevo_trabajo,
            "6": self.mostrar_trabajo,
            "7": self.modificar_trabajo,
            "8": self.eliminar_trabajo,
            "9": self.generar_informe,
            "0": self.salir
        }

    def mostrar_menu(self):
        print("""
Menú del anotador:
1.  Mostrar todos los clientes 
2.  Ingresar los datos del nuevo cliente 
3.  Actualizar datos de un cliente 
4.  Eliminar cliente 
5.  Ingresar los datos del nuevo trabajo 
6.  Mostrar trabajos 
7.  Modificar datos de trabajo (registro de trabajo retirado/finalizado)  
8.  Eliminar trabajo 
9.  Mostrar trabajos de un cliente (Informe)
0.  Salir 
""")

    def ejecutar(self):
        '''Mostrar el menu y responder a las opciones.'''
        while True:
            self.mostrar_menu()
            opcion = input("Ingresar una opción: ")
            accion = self.opciones.get(opcion)
            if accion:
                accion()
            else:
                print("{0} no es una opción válida".format(opcion))

    def mostrar_clientes(self, lista = None):
        if lista == None:
            lista = self.lista_clientes.lista
        for cliente in lista:
            print(cliente)

    def nuevo_cliente(self):
        tipo = "A"
        while tipo not in ("C", "c", "P", "p"):
            tipo =  input("Ingrese el tipo de cliente: C: Corporativo / P: Particular: ")
        nombre = input("Ingrese el nombre del contacto: ")
        if tipo in ("C", "c"):
            contacto = input("Ingrese el nombre de la empresa: ")
            tc = int(input("Ingrese el telefono de la empresa: "))
        else:
            apellido = input("Ingrese el apellido: ")
        tel = int(input("Ingrese el telefono particular: "))
        mail = input("Ingrese el correo electronico: ")
        if tipo in ("C", "c"):
            c = self.lista_clientes.nuevo_cliente_corporativo(nombre, contacto, tc, tel, mail)
        else:
            c = self.lista_clientes.nuevo_cliente_particular(nombre, apellido, tel, mail)
        if c is None:
            print("Error al cargar el trabajo")
        else:
            print("Trabajo cargado correctamente")



    def actualizar_datos(self):
        tipo = "A"
        id = int(input("Ingrese ID del cliente para actualizar sus datos: "))
        while tipo not in ("C", "c", "P", "p"):
            tipo =  input("Ingrese el tipo de cliente: C: Corporativo / P: Particular: ")
        nombre = input("Ingrese el nombre actualizado del contacto: ")
        if tipo in ("C", "c"):
            contacto = input("Ingrese el nombre actualizado  de la empresa: ")
            tc = int(input("Ingrese el telefono actualizado  de la empresa: "))
        else:
            apellido = input("Ingrese el apellido actualizado : ")
        tel = int(input("Ingrese el telefono particular actualizado : "))
        mail = input("Ingrese el correo electronico actualizado : ")
        if tipo in ("C", "c"):
            cliente = ClienteCorporativo(nombre, contacto,  tc, tel, mail, id)
            c = self.recl.update(cliente)            
        else:
            cliente = ClienteParticular(nombre, apellido, tel, mail, id)
            c = self.recl.update(cliente)  
        if c is None:
            print("Error al actualizar el cliente")
        else:
            print("Cliente actualizado correctamente")
        

    def  eliminar_cliente(self):
        id_cliente = int(input("Ingrese ID del cliente para eliminar sus datos: "))
        borrar = input("Para eliminar los datos del cliente ingrese E, de caso contrario se cancelará la eliminación: ")
        cliente = self.recl.get_one(id_cliente)
        if borrar == "E" or "e":
            c = self.recl.delete(cliente)
            print("El cliente se elimino correctamente! ")
        else:
            print("Se cancela la eliminación.")
    

    def nuevo_trabajo(self):
        id_cliente = int(input("Ingrese ID del cliente al que le desea asignar un trabajo: "))
        ingreso_trabajo = input("Ingrese N para ingresar un trabajo al cliente: ")
        cliente = self.recl.get_one(id_cliente)
        if ingreso_trabajo in ("N", "n"):
            hoy = datetime.today()
            ingreso = hoy
            dia = int(input("Ingrese el dia propuesto para la entrega: "))
            mes = int(input("Ingrese el mes propuesto para la entrega (en número, 1 a 12): "))
            anio = int(input("Ingrese el año propuesto para la entrega (4 dígitos): "))
            fecha_entrega_propuesta = datetime(anio, mes, dia)
            fecha_entrega_real = None
            descripcion = input("Ingrese una breve descripcion del trabajo: ")
            retirado = False
            t = self.listaT.nuevo_trabajo(cliente, ingreso, fecha_entrega_propuesta, fecha_entrega_real, descripcion, retirado)
            if t == 0:
                print("Error al cargar el cliente. ")
            else:
                print("Cliente cargado correctamente!")
        else: 
            if ingreso_trabajo != ("N", "n"):
                print("Ingreso de trabajo CANCELADO. ")

    def mostrar_trabajo(self, listaT = None):
        if listaT == None:
            listaT = self.listaT.listatrabajo
        for Trabajo in listaT:
            print(Trabajo)

    def modificar_trabajo(self):
        id_trabajo = int(input("Ingrese ID de trabajo al que le desea modificar un trabajo: "))
        mod_trabajo= input("Ingrese M para modificar un trabajo al cliente: ")
        trabajo = self.repotrabajo.get_one(id_trabajo)
        if mod_trabajo in ("M", "m"):
            mod_descripcion = input("Si desea modificar la descripcion presione X, si no presione otra letra: ")
            if mod_descripcion in ("X","x"):
                descripcion = input("Ingrese una breve descripcion del trabajo: ")
                trabajo.descripcion = descripcion
                mod_ingreso = input("Si desea modificar la fecha de ingreso presione X, si no presione otra letra: ")
                if mod_ingreso in ("X","x"):
                    hoy = datetime.today()
                    ingreso = hoy
                    trabajo.ingreso = ingreso
                    print("Se modifico la descripcion y la fecha de ingreso ! ")
                else:
                    print("Se modifico solamente la descripcion")
            else:
                mod_ingreso = input("Si desea modificar la fecha de ingreso presione X, si no presione otra letra: ")
                if mod_ingreso in ("X","x"):
                    hoy = datetime.today()
                    ingreso = hoy
                    trabajo.ingreso = ingreso
                    print("Se modifico la fecha de ingreso !")
                else:
                    print("No se modificó la fecha de entrega. ")
            mod_fechapropuesta = input("Si desea modificar la fecha propuesta presione X, si no presione otra letra: ")
            if mod_fechapropuesta in ("X", "x"):
                dia = int(input("Ingrese el dia propuesto para la entrega: "))
                mes = int(input("Ingrese el mes propuesto para la entrega (en número, 1 a 12): "))
                anio = int(input("Ingrese el año propuesto para la entrega (4 dígitos): "))
                fecha_entrega_propuesta = datetime(anio, mes, dia)
                trabajo.fecha_entrega_propuesta = fecha_entrega_propuesta
                print("Se modificó la fecha propuesta de entrega !")
            else:
                print("No se modifico la fecha propuesta de entrega")
            mod_fechareal = input("Ingrese X para modificar la fecha de entrega real, si no presione otra letra: ")
            if mod_fechareal in ("X", "x"):
                hoy = datetime.today()
                fecha_entrega_real = hoy
                trabajo.fecha_entrega_real = fecha_entrega_real
                print("Se modificó la fecha de entrega real. ")
            else:
                print("No se modificó la fecha de entrega real")
            mod_retirado = input("Ingrese X para modificar si el trabajo fue retirado, si no fue retirado presione N, si no presione otra letra: ")
            if mod_retirado in ("X", "x"):
                retirado = True
                trabajo.retirado = retirado
                print("El trabajó fue retirado.")
                t = self.repotrabajo.update(trabajo)                
            else:
                if mod_retirado in ("N", "n"):
                    print("El trabajo no fue retirado")
                    retirado = False  
                    trabajo.retirado = retirado
                    t = self.repotrabajo.update(trabajo)
            print("Datos actualizados correctamente !")
            t = self.repotrabajo.update(trabajo)



    def eliminar_trabajo(self):
        id_trabajo = int(input("Ingrese ID de trabajo del cliente para eliminar sus trabajos: "))
        borrar = input("Para eliminar los datos del cliente ingrese E, de caso contrario se cancelará la eliminación: ")
        trabajo = self.repotrabajo.get_one(id_trabajo)
        if borrar == "E" or "e":
            t = self.repotrabajo.delete(trabajo)
            if t == 0:
                print("El trabajo ha sido eliminado")
            else:
                print("No se eliminó correctamente")
            print("Eliminación del trabajo de manera exitosa.")
        else:
            print("Se cancela la eliminación.")


########### No se como hacer para que con el id del cliente imprima sus trabajos
########## 
    def generar_informe(self):           
        id_cliente = int(input("Ingrese el ID del cliente: "))
        cliente = self.recl.get_one(id_cliente)
        t = self.listaT.un_trabajo
        for cliente in t:
            print(cliente)






    
    
    def salir(self):

        print("Gracias por utilizar el sistema.")
        sys.exit(0)
예제 #21
0
class ListaClientes:
    def __init__(self):
        self.RC = RepositorioClientes()
        self.RT = RepositorioTrabajos()
        self.ClienteL = self.RC.get_all()
        self.ListaT = self.RT.get_all()



    def NuevoClienteCorp(self, nombre_empresa, nombre_contacto, telefono_contacto, telefono, mail):
        """Recibe los datos de un cliente corporativo, crea un nuevo cliente corporativo y lo agrega a lista de clientes"""
        C = ClienteCorporativo(nombre_empresa, nombre_contacto, telefono_contacto, telefono, mail)
        C.id_cliente = self.RC.store(C)
        if C.id_cliente == 0:
            return None
        else:
            self.ClienteL.append(C)
            return C

    def NuevoClientePart(self, nombre, apellido, telefono, mail):
        """Recibe los datos de un cliente particular, crea un nuevo cliente particular y lo agrega a la lista de clientes"""
        C = ClienteParticular(nombre, apellido, telefono, mail)
        C.id_cliente = self.RC.store(C)
        if C.id_cliente == 0:
            return None
        else:
            self.ClienteL.append(C)
            return C

    def BuscarPorID(self, id_cliente):
        """Recibe un ID y retorna un cliente"""
        for T in self.ClienteL:
            if T.id_cliente == int(id_cliente):
                return (T)
        return None


    def ModificarDatosCP(self, nombre, apellido, telefono ,mail, id_cliente):
        """Recibe los datos modificados y actualiza los datos del cliente particular"""
        C = self.BuscarPorID(id_cliente)
        if C:
            if nombre == '':
                nombre = C.nombre
            else:
                C.nombre = nombre
            if apellido == '':
                apellido = C.apellido
            else:
                C.apellido = apellido
            if telefono == '':
                telefono = C.telefono
            else:
                C.telefono = telefono
            if mail == '':
                mail = C.mail
            else:
                C.mail = mail
            return self.RC.update(C)
        return None

    def ModificarDatosCC(self, nombre_empresa, nombre_contacto, telefono_contacto, telefono, mail, id_cliente):
        """Recibe los datos modificados y actualiza los datos del cliente corporativo"""
        C = self.BuscarPorID(id_cliente)
        if C:
            if nombre_empresa == '':
                nombre_empresa = C.nombre_empresa
            else:
                C.nombre_empresa = nombre_empresa
            if nombre_contacto == '':
                nombre_contacto = C.nombre_contacto
            else:
                C.nombre_contacto = nombre_contacto
            if telefono_contacto == '':
                telefono_contacto = C.telefono_contacto
            else:
                C.telefono_contacto = telefono_contacto
            if telefono == '':
                telefono = C.telefono
            else:
                C.telefono = telefono
            if mail == '':
                mail = C.mail
            else:
                C.mail = mail
            return self.RC.update(C)
        return None

    def EliminarCliente(self, id_cliente):
        """"Recibe el ID de un cliente y lo elimina, en caso de contener trabajos, tambien los elimina"""
        C = self.BuscarPorID(id_cliente)
        for I in self.RT.get_all():
            if I.cliente.id_cliente == id_cliente:
                self.RT.delete(I)
            self.ListaT = self.RT.get_all()
        self.RC.delete(C)
        self.ClienteL = self.RC.get_all()
        return True
예제 #22
0
    def __init__(self, window):
        self.wind = window
        self.wind.title('Sistema de gestion de trabajos')
        self.rc = RepositorioClientes()
        self.lista_clientes = self.rc.get_all_particulares()
        self.rt = RepositorioTrabajos()

        #Frame
        frame = LabelFrame(self.wind, text='Menu principal')
        frame.grid(row=0, column=0, columnspan=8, pady=20)

        # Botonera
        ttk.Button(frame,
                   text="Agregar cliente particular",
                   command=self.add_clientspart_window).grid(row=1,
                                                             column=4,
                                                             columnspan=2,
                                                             sticky=W + E)
        ttk.Button(frame,
                   text="Agregar cliente corporativo",
                   command=self.add_clientscorp_window).grid(row=2,
                                                             column=4,
                                                             columnspan=2,
                                                             sticky=W + E)
        ttk.Button(frame,
                   text="Agregar un trabajo",
                   command=self.add_works_window).grid(row=3,
                                                       column=4,
                                                       columnspan=2,
                                                       sticky=W + E)

        # Mensajes de salida
        self.message = Label(text='', fg='red')
        self.message.grid(row=8, column=0, columnspan=2, sticky=W + E)

        # Tabla
        self.tree = ttk.Treeview(height=5, columns=("#1", "#2", "#3", '#4'))
        self.tree.grid(row=9, column=0, columnspan=6)

        self.tree.heading('#0', text='Nombre', anchor=CENTER)
        self.tree.heading('#1', text='Apellido', anchor=CENTER)
        self.tree.heading('#2', text='Teléfono', anchor=CENTER)
        self.tree.heading('#3', text='Mail', anchor=CENTER)
        self.tree.heading('#4', text='ID', anchor=CENTER)

        # Tabla clientes corporativos
        self.tree2 = ttk.Treeview(height=5,
                                  columns=("#1", "#2", "#3", "#4", '#5'))
        self.tree2.grid(row=11, column=0, columnspan=6)

        self.tree2.heading('#0', text='Nombre de la Empresa', anchor=CENTER)
        self.tree2.heading('#1', text='Nombre de Contacto', anchor=CENTER)
        self.tree2.heading('#2', text='Teléfono', anchor=CENTER)
        self.tree2.heading('#3', text='Teléfono de contacto', anchor=CENTER)
        self.tree2.heading('#4', text='Mail', anchor=CENTER)
        self.tree2.heading('#5', text='ID', anchor=CENTER)

        # Tabla trabajos
        self.tree3 = ttk.Treeview(height=5,
                                  columns=("#1", "#2", "#3", "#4", '#5', '#6'))
        self.tree3.grid(row=13, column=0, columnspan=6)

        self.tree3.heading('#0', text='ID de trabajo', anchor=CENTER)
        self.tree3.heading('#1', text='Nombre de cliente', anchor=CENTER)
        self.tree3.heading('#2', text='Fecha de Ingreso', anchor=CENTER)
        self.tree3.heading('#3',
                           text='Fecha de Entrega Propuesta',
                           anchor=CENTER)
        self.tree3.heading('#4', text='Fecha de Entrega Real', anchor=CENTER)
        self.tree3.heading('#5', text='Descripción', anchor=CENTER)
        self.tree3.heading('#6', text='Entregado', anchor=CENTER)

        # Botonera 2
        ttk.Button(text="Editar cliente particular",
                   command=self.edit_clients_part_window).grid(row=10,
                                                               column=1,
                                                               columnspan=2)
        ttk.Button(text="Eliminar cliente particular",
                   command=self.delete_clients_part).grid(row=10,
                                                          column=3,
                                                          columnspan=2)

        ttk.Button(text="Editar cliente corporativo",
                   command=self.edit_clients_corp_window).grid(row=12,
                                                               column=0,
                                                               columnspan=3)
        ttk.Button(text="Eliminar cliente corporativo",
                   command=self.delete_clients_corp).grid(row=12,
                                                          column=3,
                                                          columnspan=3)

        ttk.Button(text="Finalizar trabajo",
                   command=self.trabajo_finalizado).grid(row=14,
                                                         column=0,
                                                         columnspan=2)
        ttk.Button(text="Entregar el trabajo",
                   command=self.trabajo_entregado).grid(row=14,
                                                        column=1,
                                                        columnspan=2)
        ttk.Button(text="Modificar datos del trabajo",
                   command=self.edit_trabajos_window).grid(row=14,
                                                           column=2,
                                                           columnspan=2)
        ttk.Button(text="Cancelar trabajo",
                   command=self.eliminar_trabajo_confirmacion).grid(
                       row=14, column=3, columnspan=2)
        ttk.Button(text="Informe de trabajos pendientes",
                   command=self.informe).grid(row=14, column=4, columnspan=2)

        self.get_clients()
        self.get_works()
예제 #23
0
 def __init__(self):
     self.rc = RepositorioClientes()
     self.rt = RepositorioTrabajos()
     self.list_clientes = self.rc.get_all()
     self.listaTrabajo = self.rt.get_all()
예제 #24
0
 def __init__(self):
     self.RC = RepositorioClientes()
     self.RT = RepositorioTrabajos()
     self.ClienteL = self.RC.get_all()
     self.ListaT = self.RT.get_all()
예제 #25
0
class Product:

    nombre_bd = 'base_datos.sqlite'

    def __init__(self, window):
        self.wind = window
        self.wind.title('Sistema de gestion de trabajos')
        self.rc = RepositorioClientes()
        self.lista_clientes = self.rc.get_all_particulares()
        self.rt = RepositorioTrabajos()

        #Frame
        frame = LabelFrame(self.wind, text='Menu principal')
        frame.grid(row=0, column=0, columnspan=8, pady=20)

        # Botonera
        ttk.Button(frame,
                   text="Agregar cliente particular",
                   command=self.add_clientspart_window).grid(row=1,
                                                             column=4,
                                                             columnspan=2,
                                                             sticky=W + E)
        ttk.Button(frame,
                   text="Agregar cliente corporativo",
                   command=self.add_clientscorp_window).grid(row=2,
                                                             column=4,
                                                             columnspan=2,
                                                             sticky=W + E)
        ttk.Button(frame,
                   text="Agregar un trabajo",
                   command=self.add_works_window).grid(row=3,
                                                       column=4,
                                                       columnspan=2,
                                                       sticky=W + E)

        # Mensajes de salida
        self.message = Label(text='', fg='red')
        self.message.grid(row=8, column=0, columnspan=2, sticky=W + E)

        # Tabla
        self.tree = ttk.Treeview(height=5, columns=("#1", "#2", "#3", '#4'))
        self.tree.grid(row=9, column=0, columnspan=6)

        self.tree.heading('#0', text='Nombre', anchor=CENTER)
        self.tree.heading('#1', text='Apellido', anchor=CENTER)
        self.tree.heading('#2', text='Teléfono', anchor=CENTER)
        self.tree.heading('#3', text='Mail', anchor=CENTER)
        self.tree.heading('#4', text='ID', anchor=CENTER)

        # Tabla clientes corporativos
        self.tree2 = ttk.Treeview(height=5,
                                  columns=("#1", "#2", "#3", "#4", '#5'))
        self.tree2.grid(row=11, column=0, columnspan=6)

        self.tree2.heading('#0', text='Nombre de la Empresa', anchor=CENTER)
        self.tree2.heading('#1', text='Nombre de Contacto', anchor=CENTER)
        self.tree2.heading('#2', text='Teléfono', anchor=CENTER)
        self.tree2.heading('#3', text='Teléfono de contacto', anchor=CENTER)
        self.tree2.heading('#4', text='Mail', anchor=CENTER)
        self.tree2.heading('#5', text='ID', anchor=CENTER)

        # Tabla trabajos
        self.tree3 = ttk.Treeview(height=5,
                                  columns=("#1", "#2", "#3", "#4", '#5', '#6'))
        self.tree3.grid(row=13, column=0, columnspan=6)

        self.tree3.heading('#0', text='ID de trabajo', anchor=CENTER)
        self.tree3.heading('#1', text='Nombre de cliente', anchor=CENTER)
        self.tree3.heading('#2', text='Fecha de Ingreso', anchor=CENTER)
        self.tree3.heading('#3',
                           text='Fecha de Entrega Propuesta',
                           anchor=CENTER)
        self.tree3.heading('#4', text='Fecha de Entrega Real', anchor=CENTER)
        self.tree3.heading('#5', text='Descripción', anchor=CENTER)
        self.tree3.heading('#6', text='Entregado', anchor=CENTER)

        # Botonera 2
        ttk.Button(text="Editar cliente particular",
                   command=self.edit_clients_part_window).grid(row=10,
                                                               column=1,
                                                               columnspan=2)
        ttk.Button(text="Eliminar cliente particular",
                   command=self.delete_clients_part).grid(row=10,
                                                          column=3,
                                                          columnspan=2)

        ttk.Button(text="Editar cliente corporativo",
                   command=self.edit_clients_corp_window).grid(row=12,
                                                               column=0,
                                                               columnspan=3)
        ttk.Button(text="Eliminar cliente corporativo",
                   command=self.delete_clients_corp).grid(row=12,
                                                          column=3,
                                                          columnspan=3)

        ttk.Button(text="Finalizar trabajo",
                   command=self.trabajo_finalizado).grid(row=14,
                                                         column=0,
                                                         columnspan=2)
        ttk.Button(text="Entregar el trabajo",
                   command=self.trabajo_entregado).grid(row=14,
                                                        column=1,
                                                        columnspan=2)
        ttk.Button(text="Modificar datos del trabajo",
                   command=self.edit_trabajos_window).grid(row=14,
                                                           column=2,
                                                           columnspan=2)
        ttk.Button(text="Cancelar trabajo",
                   command=self.eliminar_trabajo_confirmacion).grid(
                       row=14, column=3, columnspan=2)
        ttk.Button(text="Informe de trabajos pendientes",
                   command=self.informe).grid(row=14, column=4, columnspan=2)

        self.get_clients()
        self.get_works()

    def run_query(self, query, parameters=()):
        with sqlite3.connect(self.nombre_bd) as Conectar:
            cursor = Conectar.cursor()
            resultado = cursor.execute(query, parameters)
            Conectar.commit()
        return resultado

    def get_clients(self, lista=None):
        # Limpio la tabla antes de arrancar la query
        records = self.tree.get_children()
        records2 = self.tree2.get_children()
        for element in records:
            self.tree.delete(element)
        for element2 in records2:
            self.tree2.delete(element2)

        # Muestro clientes
        query = 'SELECT * FROM cliente JOIN cliente_particular ON cliente.id=cliente_particular.id_cliente ORDER BY id ASC'
        query1 = 'SELECT * FROM cliente JOIN cliente_corporativo ON cliente.id=cliente_corporativo.id_cliente ORDER BY id ASC'
        db_rows = self.run_query(query)
        db_rows1 = self.run_query(query1)
        #Particulares
        for row in db_rows:
            self.tree.insert('',
                             0,
                             text=(row[4]),
                             values=(row[5], row[1], row[2], row[3]))
        #Corporativos
        for fila in db_rows1:
            self.tree2.insert('',
                              0,
                              text=(fila[4]),
                              values=(fila[5], fila[1], fila[6], fila[2],
                                      fila[3]))

    def get_works(self, lista=None):
        # Limpio la tabla antes de arrancar la query
        registros = self.tree3.get_children()
        for element3 in registros:
            self.tree3.delete(element3)

        # Muestro los trabajos
        query = 'SELECT trabajos.id_cliente, trabajos.fecha_ingreso, trabajos.fecha_entrega_propuesta, cliente.id,\
             trabajos.fecha_entrega_real, trabajos.descripcion, trabajos.retirado, trabajos.id, \
                 cliente_corporativo.nombre_contacto \
                     FROM trabajos \
                         JOIN cliente ON trabajos.id_cliente = cliente.id \
                             JOIN cliente_corporativo ON cliente.id = cliente_corporativo.id_cliente'

        query2 = 'SELECT trabajos.id_cliente, trabajos.fecha_ingreso, trabajos.fecha_entrega_propuesta, cliente.id,\
             trabajos.fecha_entrega_real, trabajos.descripcion, trabajos.retirado, trabajos.id, \
                 cliente_particular.nombre,cliente_particular.apellido \
                     FROM trabajos \
                         JOIN cliente ON trabajos.id_cliente = cliente.id \
                             JOIN cliente_particular ON cliente.id = cliente_particular.id_cliente'

        filas_db = self.run_query(query)
        filas2_db = self.run_query(query2)
        for filas in filas_db:
            self.tree3.insert('',
                              0,
                              text=(filas[7]),
                              values=(filas[8], filas[1], filas[2], filas[4],
                                      filas[5], filas[6]))
        for filas2 in filas2_db:
            self.tree3.insert('',
                              0,
                              text=(filas2[7]),
                              values=(filas2[8] + ' ' + filas2[9], filas2[1],
                                      filas2[2], filas2[4], filas2[5],
                                      filas2[6]))

    def validations_particular(self):
        '''Valida que no haya espacios en blanco'''
        return len(self.name.get()) != 0 and len(
            self.surname.get()) != 0 and len(self.phone.get()) != 0 and len(
                self.mail.get()) != 0

    def validations_corporativo(self):
        '''Valida que no haya espacios en blanco'''
        return len(self.company_name.get()) != 0 and len(
            self.contact_name.get()) != 0 and len(
                self.contact_phone.get()) != 0 and len(
                    self.phone.get()) != 0 and len(self.mail.get()) != 0

    def add_clientspart_window(self):

        self.add_window_part = Toplevel()
        self.add_window_part.title = 'Agregar cliente'

        # Input Nombre
        Label(self.add_window_part, text='Nombre: ').grid(row=1, column=0)
        Entry(self.add_window_part,
              textvariable=StringVar(self.add_window_part),
              state='readonly')
        self.name = Entry(self.add_window_part)
        self.name.focus()
        self.name.grid(row=1, column=1)

        # Input Apellido
        Label(self.add_window_part, text='Apellido: ').grid(row=2, column=0)
        Entry(self.add_window_part)
        self.surname = Entry(self.add_window_part)
        self.surname.grid(row=2, column=1)

        # Input Telefono
        Label(self.add_window_part, text='Telefono: ').grid(row=3, column=0)
        Entry(self.add_window_part)
        self.phone = Entry(self.add_window_part)
        self.phone.grid(row=3, column=1)

        # Input Mail
        Label(self.add_window_part, text='Mail: ').grid(row=4, column=0)
        Entry(self.add_window_part)
        self.mail = Entry(self.add_window_part)
        self.mail.grid(row=4, column=1)

        # Botonera
        ttk.Button(self.add_window_part,
                   text="Guardar",
                   command=self.add_client_particular).grid(row=5,
                                                            columnspan=2,
                                                            sticky=W + E)

    def add_clientscorp_window(self):

        self.add_window_corp = Toplevel()
        self.add_window_corp.title = 'Agregar cliente corporativo'

        # Input Nombre Empresa
        Label(self.add_window_corp, text='Nombre Empresa: ').grid(row=1,
                                                                  column=0)
        Entry(self.add_window_corp,
              textvariable=StringVar(self.add_window_corp),
              state='readonly')
        self.company_name = Entry(self.add_window_corp)
        self.company_name.focus()
        self.company_name.grid(row=1, column=1)

        # Input Nombre Contacto
        Label(self.add_window_corp, text='Nombre Contacto: ').grid(row=2,
                                                                   column=0)
        Entry(self.add_window_corp)
        self.contact_name = Entry(self.add_window_corp)
        self.contact_name.grid(row=2, column=1)

        # Input Telefono
        Label(self.add_window_corp, text='Telefono: ').grid(row=3, column=0)
        Entry(self.add_window_corp)
        self.phone = Entry(self.add_window_corp)
        self.phone.grid(row=3, column=1)

        # Input Telefono de Contacto
        Label(self.add_window_corp,
              text='Telefono de contacto: ').grid(row=4, column=0)
        Entry(self.add_window_corp)
        self.contact_phone = Entry(self.add_window_corp)
        self.contact_phone.grid(row=4, column=1)

        # Input Mail
        Label(self.add_window_corp, text='Mail: ').grid(row=5, column=0)
        Entry(self.add_window_corp)
        self.mail = Entry(self.add_window_corp)
        self.mail.grid(row=5, column=1)

        # Botonera
        ttk.Button(self.add_window_corp,
                   text="Guardar",
                   command=self.add_client_corporativo).grid(row=6,
                                                             columnspan=2,
                                                             sticky=W + E)

    def add_client_particular(self):
        #si las validaciones son correctas
        if self.validations_particular():
            parameters = ClienteParticular(self.name.get(), self.surname.get(),
                                           self.phone.get(), self.mail.get())
            parameters.id_cliente = self.rc.store(parameters)
            self.lista_clientes.append(parameters)
            self.message[
                'text'] = 'El cliente personal {0} {1} ha sido añadido correctamente'.format(
                    self.name.get(), self.surname.get())
            self.name.delete(0, END)
            self.surname.delete(0, END)
            self.phone.delete(0, END)
            self.mail.delete(0, END)
            self.get_clients()
            return parameters
        else:
            self.message[
                'text'] = 'Nombre, Apellido, Teléfono y Mail son requeridos'

    def add_client_corporativo(self):
        #si las validaciones son correctas
        if self.validations_corporativo():
            parameters = ClienteCorporativo(self.company_name.get(),
                                            self.contact_name.get(),
                                            self.contact_phone.get(),
                                            self.phone.get(), self.mail.get())
            parameters.id_cliente = self.rc.store(parameters)
            self.lista_clientes.append(parameters)
            self.message[
                'text'] = 'El cliente corporativo {0} de la empresa {1} ha sido añadido correctamente'.format(
                    self.contact_name.get(), self.company_name.get())
            self.company_name.delete(0, END)
            self.contact_name.delete(0, END)
            self.contact_phone.delete(0, END)
            self.phone.delete(0, END)
            self.mail.delete(0, END)
            self.get_clients()
            return parameters
        else:
            self.message[
                'text'] = 'Nombre, Apellido, Teléfono y Mail son requeridos'

    def edit_clients_part_window(self):
        '''Ventana para editar un cliente particular'''
        self.message['text'] = ''
        try:
            self.tree.item(self.tree.selection())['text'][0]
        except IndexError:
            self.message['text'] = 'Por favor, seleccione un registro'
            return
        old_name = self.tree.item(self.tree.selection())['text']
        old_surname = self.tree.item(self.tree.selection())['values'][0]
        old_phone = self.tree.item(self.tree.selection())['values'][1]
        old_mail = self.tree.item(self.tree.selection())['values'][2]
        id_cliente1 = self.tree.item(self.tree.selection())['values'][3]
        self.edit_window = Toplevel()
        self.edit_window.title = 'Editar cliente'

        # ID
        Label(self.edit_window, text='ID: ').grid(row=1, column=1)
        Entry(self.edit_window,
              textvariable=StringVar(self.edit_window, value=id_cliente1),
              state='readonly').grid(row=1, column=2)

        # Nombre Anterior
        Label(self.edit_window, text='Nombre anterior: ').grid(row=2, column=1)
        Entry(self.edit_window,
              textvariable=StringVar(self.edit_window, value=old_name),
              state='readonly').grid(row=2, column=2)

        # Nombre Actual
        Label(self.edit_window, text='Nombre actual: ').grid(row=3, column=1)
        new_name = Entry(self.edit_window)
        new_name.grid(row=3, column=2)

        # Apellido Anterior
        Label(self.edit_window, text='Apellido Anterior: ').grid(row=4,
                                                                 column=1)
        Entry(self.edit_window,
              textvariable=StringVar(self.edit_window, value=old_surname),
              state='readonly').grid(row=4, column=2)

        # Nuevo Apellido
        Label(self.edit_window, text='Apellido Actual: ').grid(row=5, column=1)
        new_surname = Entry(self.edit_window)
        new_surname.grid(row=5, column=2)

        # Telefono Anterior
        Label(self.edit_window, text='Telefono Anterior: ').grid(row=6,
                                                                 column=1)
        Entry(self.edit_window,
              textvariable=StringVar(self.edit_window, value=old_phone),
              state='readonly').grid(row=6, column=2)

        # Nuevo Telefono
        Label(self.edit_window, text='Telefono Actual: ').grid(row=7, column=1)
        new_phone = Entry(self.edit_window)
        new_phone.grid(row=7, column=2)

        # Mail anterior
        Label(self.edit_window, text='Mail Anterior: ').grid(row=8, column=1)
        Entry(self.edit_window,
              textvariable=StringVar(self.edit_window, value=old_mail),
              state='readonly').grid(row=8, column=2)

        # Nuevo mail
        Label(self.edit_window, text='Mail Actual: ').grid(row=9, column=1)
        new_mail = Entry(self.edit_window)
        new_mail.grid(row=9, column=2)

        # Botón de guardar cambios
        ttk.Button(self.edit_window,
                   text='Actualizar',
                   command=lambda: self.edit_clients_part(
                       new_name.get(), new_surname.get(), new_phone.get(),
                       new_mail.get(), id_cliente1)).grid(row=10,
                                                          columnspan=3,
                                                          sticky=W + E)

    def edit_clients_part(self, new_name, new_surname, new_phone, new_mail,
                          id_cliente):
        '''Editar un cliente particular'''
        parameters = ClienteParticular(new_name, new_surname, new_phone,
                                       new_mail, id_cliente)
        self.rc.update(parameters)
        self.edit_window.destroy()
        self.message[
            'text'] = 'El cliente {0} {1} sido editado correctamente'.format(
                new_name, new_surname)
        self.get_clients()

    def edit_clients_corp_window(self):
        '''Ventana para editar un cliente corporativo'''
        self.message['text'] = ''
        try:
            self.tree2.item(self.tree2.selection())['text'][0]
        except IndexError:
            self.message['text'] = 'Por favor, seleccione un registro'
            return
        old_company_name = self.tree2.item(self.tree2.selection())['text']
        old_contact_name = self.tree2.item(self.tree2.selection())['values'][0]
        old_contact_phone = self.tree2.item(
            self.tree2.selection())['values'][1]
        old_phone = self.tree2.item(self.tree2.selection())['values'][2]
        old_mail = self.tree2.item(self.tree2.selection())['values'][3]
        id_cliente = self.tree2.item(self.tree2.selection())['values'][4]
        self.edit_window2 = Toplevel()
        self.edit_window2.title = 'Editar cliente'

        # ID
        Label(self.edit_window2, text='ID: ').grid(row=0, column=1)
        Entry(self.edit_window2,
              textvariable=StringVar(self.edit_window2, value=id_cliente),
              state='readonly').grid(row=0, column=2)

        # Nombre de la empresa Anterior
        Label(self.edit_window2,
              text='Nombre de la empresa anterior: ').grid(row=1, column=1)
        Entry(self.edit_window2,
              textvariable=StringVar(self.edit_window2,
                                     value=old_company_name),
              state='readonly').grid(row=1, column=2)

        # Nombre de la empresa Actual
        Label(self.edit_window2,
              text='Nombre de la empresa actual: ').grid(row=2, column=1)
        new_company_name = Entry(self.edit_window2)
        new_company_name.grid(row=2, column=2)

        # Nombre de contacto Anterior
        Label(self.edit_window2,
              text='Nombre de contacto anterior: ').grid(row=3, column=1)
        Entry(self.edit_window2,
              textvariable=StringVar(self.edit_window2,
                                     value=old_contact_name),
              state='readonly').grid(row=3, column=2)

        # Nombre de contacto Actual
        Label(self.edit_window2,
              text='Nombre de contacto actual: ').grid(row=4, column=1)
        new_contact_name = Entry(self.edit_window2)
        new_contact_name.grid(row=4, column=2)

        # Telefono Anterior
        Label(self.edit_window2, text='Telefono Anterior: ').grid(row=5,
                                                                  column=1)
        Entry(self.edit_window2,
              textvariable=StringVar(self.edit_window2, value=old_phone),
              state='readonly').grid(row=5, column=2)

        # Nuevo Telefono
        Label(self.edit_window2, text='Telefono Actual: ').grid(row=6,
                                                                column=1)
        new_phone = Entry(self.edit_window2)
        new_phone.grid(row=6, column=2)

        # Telefono de contacto Anterior
        Label(self.edit_window2,
              text='Telefono de contacto anterior: ').grid(row=7, column=1)
        Entry(self.edit_window2,
              textvariable=StringVar(self.edit_window2,
                                     value=old_contact_phone),
              state='readonly').grid(row=7, column=2)

        # Telefono de contacto actual
        Label(self.edit_window2,
              text='Telefono de contacto actual: ').grid(row=8, column=1)
        new_contact_phone = Entry(self.edit_window2)
        new_contact_phone.grid(row=8, column=2)

        # Mail Anterior
        Label(self.edit_window2, text='Mail anterior: ').grid(row=9, column=1)
        Entry(self.edit_window2,
              textvariable=StringVar(self.edit_window2, value=old_mail),
              state='readonly').grid(row=9, column=2)

        # Mail actual
        Label(self.edit_window2, text='Mail actual: ').grid(row=10, column=1)
        new_mail = Entry(self.edit_window2)
        new_mail.grid(row=10, column=2)

        # Botón de guardar cambios
        ttk.Button(
            self.edit_window2,
            text='Actualizar',
            command=lambda: self.edit_clients_corp(new_company_name.get(
            ), new_contact_name.get(), new_contact_phone.get(), new_phone.get(
            ), new_mail.get(), id_cliente)).grid(row=11,
                                                 columnspan=3,
                                                 sticky=W + E)

    def edit_clients_corp(self, new_company_name, new_contact_name,
                          new_contact_phone, new_phone, new_mail, id_cliente):
        '''Editar un cliente corporativo'''
        parameters = ClienteCorporativo(new_company_name, new_contact_name,
                                        new_contact_phone, new_phone, new_mail,
                                        id_cliente)
        self.rc.update(parameters)
        self.edit_window2.destroy()
        self.message[
            'text'] = 'El cliente {0} de la empresa {1} ha sido editado correctamente'.format(
                new_contact_name, new_company_name)
        self.get_clients()

    def delete_clients_part(self):
        '''Eliminar a un cliente particular'''
        name = self.tree.item(self.tree.selection())['text']
        surname = self.tree.item(self.tree.selection())['values'][0]
        phone = self.tree.item(self.tree.selection())['values'][1]
        mail = self.tree.item(self.tree.selection())['values'][2]
        id_cliente1 = self.tree.item(self.tree.selection())['values'][3]
        try:
            self.tree.item(self.tree.selection())['text']
        except IndexError:
            self.message['text'] = 'Seleccione a un cliente'
        name = self.tree.item(self.tree.selection())['text']
        parameters = ClienteParticular(name, surname, phone, mail, id_cliente1)
        self.rc.delete(parameters)
        self.message[
            'text'] = 'El cliente {0} {1} sido editado correctamente'.format(
                name, surname)
        self.get_clients()

    def delete_clients_corp(self):
        '''Eliminar a un cliente corporativo'''
        company_name = self.tree2.item(self.tree2.selection())['text']
        contact_name = self.tree2.item(self.tree2.selection())['values'][0]
        contact_phone = self.tree2.item(self.tree2.selection())['values'][1]
        phone = self.tree2.item(self.tree2.selection())['values'][2]
        mail = self.tree2.item(self.tree2.selection())['values'][3]
        id_cliente1 = self.tree2.item(self.tree2.selection())['values'][4]
        try:
            self.tree.item(self.tree2.selection())['text']
        except IndexError:
            self.message['text'] = 'Seleccione a un cliente'
        parameters = ClienteCorporativo(company_name, contact_name,
                                        contact_phone, phone, mail,
                                        id_cliente1)
        self.rc.delete(parameters)
        self.message[
            'text'] = 'El cliente {0} de la empresa {1} sido eliminado correctamente'.format(
                contact_name, company_name)
        self.get_clients()

    def add_works_window(self):

        self.add_window_work = Toplevel()
        self.add_window_work.title = 'Agregar trabajo'

        # Input ID

        Label(self.add_window_work, text='ID del cliente: ').grid(row=1,
                                                                  column=0)
        self.id_cliente_entry = Entry(self.add_window_work)
        self.id_cliente_entry.focus()
        self.id_cliente_entry.grid(row=1, column=1)

        # Input Fecha de Ingreso
        Label(self.add_window_work, text='Fecha de Ingreso: ').grid(row=2,
                                                                    column=0)
        self.entry_date = Entry(self.add_window_work)
        self.entry_date.grid(row=2, column=1)

        # Input Fecha de Entrega Propuesta
        Label(self.add_window_work,
              text='Fecha de Entrega Propuesta: ').grid(row=3, column=0)
        self.proposal_delivery_date = Entry(self.add_window_work)
        self.proposal_delivery_date.grid(row=3, column=1)

        # Input Descripcion
        Label(self.add_window_work, text='Descripcion: ').grid(row=5, column=0)
        self.description = Entry(self.add_window_work)
        self.description.grid(row=5, column=1)

        # Botonera
        ttk.Button(self.add_window_work, text="Guardar",
                   command=self.add_work).grid(row=7,
                                               columnspan=2,
                                               sticky=W + E)

    def validations_work(self):
        #'''Valida que no haya espacios en blanco'''
        return len(self.id_cliente_entry.get())

    def add_work(self):
        #si las validaciones son correctass
        if self.validations_work():
            self.message['text'] = ''
            obj_cliente = None
            obj_cliente = self.rc.get_one(self.id_cliente_entry.get())
            fe_entrada = datetime.strptime(self.entry_date.get(), '%d-%m-%Y')
            fe_entrada.strftime('%Y-%m-%d')
            fecha_ent_pro = ''

            # En caso de que la fecha propuesta esté en blanco, asignar None
            if fecha_ent_pro != '':
                fecha_ent_pro = datetime.strptime(
                    self.proposal_delivery_date.get(), '%d-%m-%Y')
                fecha_ent_pro.strftime('%Y-%m-%d')
            else:
                fecha_ent_pro = None

            parameters = Trabajo(obj_cliente, fe_entrada, fecha_ent_pro, None,
                                 self.description.get(), False, None)
            a = self.rt.store(parameters)
            print(parameters, a)
            if a:
                self.message[
                    'text'] = 'El trabajo del cliente {0} ha sido añadido correctamente'.format(
                        self.id_cliente_entry.get())
                self.get_works()
                self.id_cliente_entry.delete(0, END)
                self.entry_date.delete(0, END)
                self.proposal_delivery_date.delete(0, END)
                self.description.delete(0, END)
            else:
                self.message[
                    'text'] = 'El trabajo del cliente no se ha sido añadido. Código de error: 0'
                print(fecha_ent_pro)

        else:
            self.message['text'] = 'Todos los campos son requeridos'

    def retirado(self):
        '''Se cambia su estado de retirado a True'''
        try:
            self.tree3.item(self.tree3.selection())['text']
        except IndexError:
            self.message['text'] = 'Seleccione un trabajo'

        self.message['text'] = 'El trabajo ha sido entregado correctamente'
        self.get_works()

    def edit_trabajos_window(self):
        '''Ventana para editar un trabajo'''
        self.message['text'] = ''
        try:
            self.tree3.item(self.tree3.selection())['values'][0]
        except IndexError:
            self.message['text'] = 'Por favor, seleccione un registro'
            return
        old_description = self.tree3.item(self.tree3.selection())['values'][4]
        old_entry_date = self.tree3.item(self.tree3.selection())['values'][1]
        id_cliente = self.tree3.item(self.tree3.selection())['values'][0]
        proposal_delivery_date = self.tree3.item(
            self.tree3.selection())['values'][2]
        real_delivery_date = self.tree3.item(
            self.tree3.selection())['values'][3]

        if real_delivery_date == None:
            real_delivery_date = '01-01-1981'
        else:
            real_delivery_date = real_delivery_date

        withdrawn = self.tree3.item(self.tree3.selection())['values'][5]
        id_trabajo = self.tree3.item(self.tree3.selection())['text']
        self.edit_work_window = Toplevel()
        self.edit_work_window.title = 'Editar trabajo'

        # ID
        Label(self.edit_work_window, text='ID: ').grid(row=1, column=1)
        Entry(self.edit_work_window,
              textvariable=StringVar(self.edit_work_window, value=id_trabajo),
              state='readonly').grid(row=1, column=2)

        # Descripcion Anterior
        Label(self.edit_work_window,
              text='Descripcion anterior: ').grid(row=2, column=1)
        Entry(self.edit_work_window,
              textvariable=StringVar(self.edit_work_window,
                                     value=old_description),
              state='readonly').grid(row=2, column=2)

        # Descripcion Actual
        Label(self.edit_work_window,
              text='Descripcion actual: ').grid(row=3, column=1)
        new_description = Entry(self.edit_work_window)
        new_description.grid(row=3, column=2)

        # Fecha propuesta anterior
        Label(self.edit_work_window,
              text='Fecha propuesta anterior: ').grid(row=4, column=1)
        Entry(self.edit_work_window,
              textvariable=StringVar(self.edit_work_window,
                                     value=proposal_delivery_date),
              state='readonly').grid(row=4, column=2)

        # Fecha propuesta actual
        Label(self.edit_work_window,
              text='Fecha propuesta actual: ').grid(row=5, column=1)
        new_proposal_date = Entry(self.edit_work_window)
        new_proposal_date.grid(row=5, column=2)

        # Fecha de Ingreso Anterior
        Label(self.edit_work_window,
              text='Fecha de ingreso anterior: ').grid(row=6, column=1)
        Entry(self.edit_work_window,
              textvariable=StringVar(self.edit_work_window,
                                     value=old_entry_date),
              state='readonly').grid(row=6, column=2)

        # Fecha de Ingreso Actual
        Label(self.edit_work_window,
              text='Fecha de ingreso actual: ').grid(row=7, column=1)
        new_entry_date = Entry(self.edit_work_window)
        new_entry_date.grid(row=7, column=2)

        # Botón de guardar cambios
        ttk.Button(self.edit_work_window,
                   text='Actualizar',
                   command=lambda: self.edit_works_desc(
                       id_cliente, new_entry_date.get(), new_proposal_date.get(
                       ), real_delivery_date, new_description.get(), withdrawn,
                       id_trabajo)).grid(row=8, columnspan=3, sticky=W + E)

    def edit_works_desc(self, id_cliente, new_entry_date, new_proposal_date,
                        real_delivery_date, new_description, withdrawn,
                        id_trabajo):
        '''Editar descripcion y fecha de ingreso'''
        nueva_fecha = datetime.strptime(new_entry_date, '%d-%m-%Y')
        nueva_fecha.strftime('%Y-%m-%d')
        fecha_ent_pro = datetime.strptime(new_proposal_date, '%d-%m-%Y')
        fecha_ent_pro.strftime('%Y-%m-%d')

        if real_delivery_date == 'None':
            real_delivery_date = '01-01-1981'
            fecha_ent_re = datetime.strptime(real_delivery_date, '%Y-%m-%d')
            fecha_ent_re.strftime('%Y-%m-%d')
        else:
            fecha_ent_re = datetime.strptime(real_delivery_date, '%Y-%m-%d')
            fecha_ent_re.strftime('%Y-%m-%d')

        parameters = Trabajo(id_cliente, nueva_fecha, fecha_ent_pro,
                             fecha_ent_re, new_description, withdrawn,
                             id_trabajo)

        a = self.rt.update(parameters)
        if a:
            self.edit_work_window.destroy()
            self.message['text'] = 'El trabajo sido editado correctamente'
        else:
            self.message['text'] = 'El trabajo no ha sido editado'
        self.get_works()

    def trabajo_finalizado(self):
        '''Cambiar el estado a finalizado, modificando su fecha de entrega real a hoy'''
        try:
            self.tree3.item(self.tree3.selection())['values'][0]
        except IndexError:
            self.message['text'] = 'Por favor, seleccione un registro'
            return
        # Obtengo la fecha de hoy
        hoy = date.today()
        hoy.strftime('%d, %m, %Y')

        # Obtengo los datos actuales del objeto en cuestión
        description = self.tree3.item(self.tree3.selection())['values'][4]
        entry_date = self.tree3.item(self.tree3.selection())['values'][1]
        id_cliente = self.tree3.item(self.tree3.selection())['values'][0]
        proposal_delivery_date = self.tree3.item(
            self.tree3.selection())['values'][2]
        #old_real_delivery_date = self.tree3.item(self.tree3.selection())['values'][3]
        withdrawn = self.tree3.item(self.tree3.selection())['values'][5]
        id_trabajo = self.tree3.item(self.tree3.selection())['text']

        # Formateo las fechas
        nueva_fecha = datetime.strptime(entry_date, '%Y-%m-%d')
        nueva_fecha.strftime('%Y-%m-%d')

        if proposal_delivery_date == 'None':
            proposal_delivery_date = '2000-01-01'
        else:
            proposal_delivery_date = proposal_delivery_date

        fecha_ent_pro = datetime.strptime(proposal_delivery_date, '%Y-%m-%d')
        fecha_ent_pro.strftime('%Y-%m-%d')
        fecha_ent_pro = datetime.strptime(proposal_delivery_date, '%Y-%m-%d')
        fecha_ent_pro.strftime('%Y-%m-%d')

        # Paso parametros al obj Trabajo
        parameters = Trabajo(id_cliente, nueva_fecha, fecha_ent_pro, hoy,
                             description, withdrawn, id_trabajo)

        a = self.rt.update(parameters)
        if a:
            self.message['text'] = 'El trabajo sido editado correctamente'
        else:
            self.message['text'] = 'El trabajo no ha sido editado'
        self.get_works()

    def trabajo_entregado(self):
        '''Cambiar el estado a entregado'''
        try:
            self.tree3.item(self.tree3.selection())['values'][0]
        except IndexError:
            self.message['text'] = 'Por favor, seleccione un registro'
            return

        # Obtengo los datos actuales del objeto en cuestión
        description = self.tree3.item(self.tree3.selection())['values'][4]
        entry_date = self.tree3.item(self.tree3.selection())['values'][1]
        id_cliente = self.tree3.item(self.tree3.selection())['values'][0]
        proposal_delivery_date = self.tree3.item(
            self.tree3.selection())['values'][2]
        real_delivery_date = self.tree3.item(
            self.tree3.selection())['values'][3]
        #withdrawn = self.tree3.item(self.tree3.selection())['values'][5]
        id_trabajo = self.tree3.item(self.tree3.selection())['text']

        # Formateo las fechas
        nueva_fecha = datetime.strptime(entry_date, '%Y-%m-%d')
        nueva_fecha.strftime('%Y-%m-%d')
        fecha_ent_pro = datetime.strptime(proposal_delivery_date, '%Y-%m-%d')
        fecha_ent_pro.strftime('%Y-%m-%d')
        fecha_ent_real = datetime.strptime(real_delivery_date, '%Y-%m-%d')
        fecha_ent_real.strftime('%Y-%m-%d')

        withdrawn = True

        # Paso parametros al obj Trabajo
        parameters = Trabajo(id_cliente, nueva_fecha, fecha_ent_pro,
                             fecha_ent_real, description, withdrawn,
                             id_trabajo)

        a = self.rt.update(parameters)
        if a:
            self.message[
                'text'] = 'El trabajo {0} sido entregado correctamente'.format(
                    id_trabajo)
        else:
            self.message['text'] = 'El trabajo no ha sido editado'
        self.get_works()

    def eliminar_trabajo_confirmacion(self):
        '''ventana para confirmar la eliminación de los trabajos'''
        # Creo ventana
        self.delete_work_window = Toplevel()
        self.delete_work_window.title = 'Eliminar trabajo'

        # Label
        label = Label(self.delete_work_window,
                      text='¿Está seguro que desea eliminar el trabajo?')
        label.grid(row=1, column=0)

        # Botón de Confirmar
        ttk.Button(self.delete_work_window,
                   text='Sí, eliminar',
                   command=lambda: self.eliminar_trabajo()).grid(row=2,
                                                                 column=0)
        # Botón Cancelar
        ttk.Button(self.delete_work_window,
                   text='NO, cancelar',
                   command=lambda: self.delete_work_window.destroy()).grid(
                       row=3, column=0)

    def eliminar_trabajo(self):
        '''Eliminar un trabajo de la BD'''

        # Obtengo los datos actuales del objeto en cuestión
        description = self.tree3.item(self.tree3.selection())['values'][4]
        entry_date = self.tree3.item(self.tree3.selection())['values'][1]
        id_cliente = self.tree3.item(self.tree3.selection())['values'][0]
        proposal_delivery_date = self.tree3.item(
            self.tree3.selection())['values'][2]
        real_delivery_date = self.tree3.item(
            self.tree3.selection())['values'][3]
        withdrawn = self.tree3.item(self.tree3.selection())['values'][5]
        id_trabajo = self.tree3.item(self.tree3.selection())['text']

        # Paso parametros al obj Trabajo
        parameters = Trabajo(id_cliente, entry_date, proposal_delivery_date,
                             real_delivery_date, description, withdrawn,
                             id_trabajo)
        a = self.rt.delete(parameters)

        # Códigos de éxito o error y retorno la lista de trabajos actualizados
        if a:
            self.message[
                'text'] = 'El trabajo {0} sido eliminado correctamente'.format(
                    id_trabajo)
        else:
            self.message['text'] = 'El trabajo no ha sido eliminado'
        self.get_works()

    def informe(self):

        # Creo ventana
        self.informe_trabajos_window = Toplevel()
        self.informe_trabajos_window.title = 'Informe'

        # Obtengo la fecha de hoy
        hoy = date.today()
        hoyhoy = hoy.strftime('%Y-%m-%d')

        # Traigo todos los parámetros para comparar la fecha y la entrega
        trabajos_deben = []
        clientes_deben = []
        trabajos_no_deben = []
        clientes_no_deben = []
        fecha_propuesta = []

        trabajos_realmente_deben = []

        for Parent in self.tree3.get_children():
            entregado = self.tree3.item(Parent)["values"][5]
            id_cliente = self.tree3.item(Parent)['text']
            fecha_entrega_propuesta = self.tree3.item(Parent)['values'][3]
            if entregado == 0:
                trabajos_deben.append(entregado)
                clientes_deben.append(id_cliente)
                fecha_propuesta.append(fecha_entrega_propuesta)
            else:
                trabajos_no_deben.append(entregado)
                clientes_no_deben.append(id_cliente)

        #print (fecha_propuesta)
        cant_trabajos = len(trabajos_deben)

        for i in fecha_propuesta:
            if i <= hoyhoy:
                trabajos_realmente_deben.append(i)

        print("Al dia de hoy", hoyhoy, "faltan entregar", cant_trabajos,
              "trabajos")
        # Label
        label = Label(self.informe_trabajos_window, text='Informes')
        label.grid(row=1, column=0)

        label2 = Label(self.informe_trabajos_window,
                       text="El informe sale por consola")
        label2.grid(row=1, column=0)

        # Botón Cierre
        ttk.Button(
            self.informe_trabajos_window,
            text='Cerrar',
            command=lambda: self.informe_trabajos_window.destroy()).grid(
                row=2, column=0)
예제 #26
0
class ListaTrabajos:
    def __init__(self):
        self.RT = RepositorioTrabajos()
        self.TrabajoL = self.RT.get_all()

    def NuevoTrabajo(self, cliente, fecha_ingreso, fecha_entrega_propuesta,
                     descripcion):
        """Recibe los datos de un trabajo, crea un nuevo trabajo y lo agrega a la lista trabajos"""
        T = Trabajo(cliente, fecha_ingreso, fecha_entrega_propuesta, None,
                    descripcion, False)
        T.id_trabajo = self.RT.store(T)
        if T.id_trabajo == 0:
            return None
        else:
            self.TrabajoL.append(T)
            return T

    def BuscarPorID(self, id_trabajo):
        """Recibe un ID y retorna un trabajo"""
        for T in self.TrabajoL:
            if T.id_trabajo == int(id_trabajo):
                return (T)
        return None

    def TrabajoFinalizado(self, id_trabajo):
        """Recibe un trabajo y le modifica la fecha de entrega"""
        T = self.BuscarPorID(id_trabajo)
        if T:
            T.fecha_entrega_real = datetime.date.today()
            return self.RT.update(T)
        return None

    def Trabajo_retirado(self, id_trabajo):
        """Recibe un trabajo y modifica el trabajo como retirado"""
        T = self.BuscarPorID(id_trabajo)
        if T:
            if T.fecha_entrega_real == None:
                T.retirado = True
                self.TrabajoFinalizado(id_trabajo)
            else:
                T.retirado = True
            return self.RT.update(T)
        return None

    def ModificarDatosT(self, fecha_ingreso, fecha_entrega_propuesta,
                        descripcion, id_trabajo):
        """Recibe un trabajo y modifica sus datos"""
        T = self.BuscarPorID(id_trabajo)
        if T:
            T.fecha_ingreso = fecha_ingreso
            T.fecha_entrega_propuesta = fecha_entrega_propuesta
            T.descripcion = descripcion
            return self.RT.update(T)
        return None

    def EliminarTrabajo(self, id_trabajo):
        T = self.BuscarPorID(id_trabajo)
        if T:
            self.RT.delete(T)
            self.TrabajoL = self.RT.get_all()
            return True
        return None
예제 #27
0
 def __init__(self):
     self.repostrabajos = RepositorioTrabajos()
     self.lista = self.repostrabajos.get_all()
예제 #28
0
class Menu:
    "Muestra un menu para que se responda a las opciones"

    def __init__(self):
        self.lista_clientes = ListaClientes()
        self.repositoriocl = RepositorioClientes()
        self.lista = self.repositoriocl.get_all()
        self.repositoriotr = RepositorioTrabajos()
        self.LT = ListaTrabajos()
        self.opciones = {
            "1": self.mostrar_clientes,
            "2": self.nuevo_cliente,
            "3": self.modificar_cliente,
            "4": self.eliminar_cliente,
            "5": self.carga_trabajo,
            "6": self.modificar_trabajo,
            "7": self.mostrar_trabajos,
            "8": self.HistorialTrabajosCl,
            "0": self.salir
        }

    def mostrar_menu(self):
        print("""
Menu del sistema:
1. Mostrar todos los clientes
2. Ingreso de nuevo cliente
3. Modificacion de cliente
4. Eliminacion de cliente
5. Carga de nuevo trabajo
6. Modificar datos de un trabajo
7. Mostrar todos los trabajos
8. Informe
0. Salir
""")

    def ejecutar(self):
        "Muestra el menu y responde a las opciones."
        while True:
            self.mostrar_menu()
            opcion = input("Ingresar una opcion: ")
            accion = self.opciones.get(opcion)
            if accion:
                accion()
            else:
                print("{0} no es una opcion valida".format(opcion))

    #CLIENTE // Mostrar todos los clientes.
    def mostrar_clientes(self, lista=None):
        if lista == None:
            lista = self.repositoriocl.get_all()
        for cliente in lista:
            print(cliente)
            print("==========================")

    #CLIENTE // Ingreso de cliente.
    def nuevo_cliente(self):
        tipo = "A"
        while tipo not in ("C", "c", "P", "p"):
            tipo = input(
                "Ingrese el tipo de cliente: C: Corporativo/ P:Particular")
        nombre = input("Ingrese el nombre:")
        if tipo in ("C", "c"):
            contacto = input("Ingrese el nombre del contacto: ")
            tc = input("Ingrese el telefono del contacto: ")
        else:
            apellido = input("Ingrese el apellido: ")
        tel = input("Ingrese el telefono: ")
        mail = input("Ingresa la direccion de email: ")
        if tipo in ("C", "c"):
            c = self.lista_clientes.nuevo_cliente_corporativo(
                nombre, contacto, tc, tel, mail)
        else:
            c = self.lista_clientes.nuevo_cliente_particular(
                nombre, apellido, tel, mail)
        if c is None:
            print("Error al cargar el cliente")
        else:
            print("Cliente cargado correctamente")

    #CLIENTE // Modificacion de cliente.
    def modificar_cliente(self):
        tipo = "A"
        id_cliente = int(input("Ingrese el ID del cliente registrado: "))
        while tipo not in ("C", "c", "P", "p"):
            tipo = input(
                "Ingrese el tipo de cliente: C: Corporativo/ P: Particular ")
        nombre = input("Ingrese el nombre: ")
        if tipo in ("C", "c"):
            contacto = input("Ingrese el nombre del contacto: ")
            tc = input("Ingrese el telefono del contacto: ")
        else:
            apellido = input("Ingrese el apellido: ")
        tel = input("Ingrese el telefono: ")
        mail = input("Ingresa la direccion de email: ")
        if tipo in ("C", "c"):
            cliente = ClienteCorporativo(nombre, contacto, tc, tel, mail,
                                         id_cliente)
            c = self.repositoriocl.update(cliente)
        else:
            cliente = ClienteParticular(nombre, apellido, tel, mail,
                                        id_cliente)
            c = self.repositoriocl.update(cliente)

        if c is None:
            print("Error al modificar el cliente")
        else:
            print("Cliente modificado correctamente")

    #CLIENTE // Suprimir un cliente.
    def eliminar_cliente(self):
        id_cliente = int(input("Ingrese el id del cliente"))
        c = self.repositoriocl.get_one(id_cliente)
        if c == None:
            print("El id del cliente no esta cargado en nuestra base de datos")
        else:
            self.repositoriocl.delete(c)
            print("El cliente fue eliminado correctamente!")

    #TRABAJO // Carga de un nuevo trabajo.
    def carga_trabajo(self):
        id_cliente = int(input("Ingrese el id del cliente: "))
        rc = RepositorioClientes()
        cl = rc.get_one(id_cliente)
        fecha_ingreso = datetime.date.today()
        dia = int(input("Ingrese el dia: "))
        mes = int(input("Ingrese el mes: "))
        anio = int(input("Ingrese el anio: "))
        fecha_entrega_propuesta = datetime.date(anio, mes, dia)
        descripcion_trabajo = input(
            "Ingrese una descripcion del trabajo a realizar: ")
        c = self.LT.nuevo_trabajo(cl, fecha_ingreso, fecha_entrega_propuesta,
                                  descripcion_trabajo)
        if c == None:
            print("Error, no puede cargarse el nuevo trabajo ")
        else:
            print("Trabajo cargado correctamente en la base de datos! ")

    #TRABAJO // Modificar datos de los trabajos cargados. // FechaING-PROP-REAL-DESC-ESTADO DEL TRABAJO.
    def modificar_trabajo(self):
        print(
            "Al ingresar un ID de trabajo se tendran que modificar todos los datos, en caso de que quede un campo vacio se modificara de esa forma"
        )
        id_trabajo = int(input("Ingrese el ID del trabajo: "))
        C = self.repositoriotr.get_one(id_trabajo)
        if C == None:
            print("No se encontro el trabajo")
        else:
            t = input(
                "Si desea modificar la fecha de ingreso presione f, de lo contrario presione 0 para continuar: "
            )
            if t in ("f", "F"):
                dia = int(input("Ingrese nuevamente el dia: "))
                mes = int(input("Ingrese nuevamente el mes: "))
                anio = int(input("Ingrese nuevamente el anio: "))
                print("Fecha modificada exitosamente! ")
                fechaingreso = datetime.date(anio, mes, dia)
            else:
                fechaingreso = C.fecha_ingreso
            t = input(
                "Si desea modificar la fecha de entrega propuesta de un trabajo presione la tecla e, de lo contrario presione 0 para continuar: "
            )
            if t in ("e", "E"):
                dia = int(input("Ingrese nuevamente el dia: "))
                mes = int(input("Ingrese nuevamente el mes: "))
                anio = int(input("Ingrese nuevamente el anio: "))
                print("Fecha modificada exitosamente! ")
                fentregapropuesta = datetime.date(anio, mes, dia)
            else:
                fentregapropuesta = C.fecha_entrega_propuesta
                print("Ningun dato se ha modificado")
            t = input(
                "Si desea modificar la fecha real de un trabajo presione la tecla r, de lo contrario presione 0 para continuar: "
            )
            if t in ("r", "R"):
                dia = int(input("Ingrese nuevamente el dia: "))
                mes = int(input("Ingrese nuevamente el mes: "))
                anio = int(input("Ingrese nuevamente el anio: "))
                print("Fecha modificada exitosamente! ")
                fentregareal = datetime.date(anio, mes, dia)
            else:
                fentregareal = C.fecha_entrega_real
                print("No se ha modificado la fecha! ")
            t = input(
                "Si desea modificar la descripcion de un trabajo presione la tecla t, de lo contrario presione 0 para continuar: "
            )
            if t in ("t", "T"):
                t = input("Ingrese la nueva descripcion del trabajo: ")
                print("Se ha modificado el nombre del trabajo! ")
                descripcion = t
            else:
                C.descripcion = descripcion
                print("La descripcion del trabajo no ha podido modificarse")
            trabajo = self.LT.modificar_trabajo(fechaingreso,
                                                fentregapropuesta,
                                                fentregareal, descripcion,
                                                id_trabajo)
            self.repositoriocl.update(trabajo)
            self.LT.TrabajoL = self.repositoriotr.get_all()

    #TRABAJO // Mostrar todos los trabajos.
    def mostrar_trabajos(self, listat=None):
        if listat == None:
            listat = self.repositoriotr.get_all()
        for cliente in listat:
            print(cliente)
            print("============================")

    #INFORME // Despliega una lista con los trabajos cargados en cada cliente.
    def HistorialTrabajosCl(self):
        "Pide un ID y muestra una lista con los trabajos cargados en cada cliente"
        for i in self.repositoriocl.get_all_particulares():
            print("=====================================")
            print("ID cliente: ", i.id_cliente, "- Nombre: ", i.nombre)
            print("=====================================")
        for i in self.repositoriocl.get_all_corporativos():
            print("=====================================")
            print("ID cliente: ", i.id_cliente, "- Nombre: ", i.nombre_empresa)
        id = int(input("Ingrese el ID del cliente: "))
        C = self.repositoriotr.get_one(id)
        if C == None:
            print()
        else:
            print("=====================================")
            print(C)
            print("=====================================")
            for I in self.LT.TrabajoL:
                if I.cliente.id_cliente == id:
                    print("========================================")
                    print("ID trabajo: ", I.id_trabajo)
                    print("Fecha de ingreso: ", I.fecha_ingreso)
                    print("Fecha entrega propuesta: ",
                          I.fecha_entrega_propuesta)
                    print("Fecha entrega real: ", I.fecha_entrega_real)
                    print("Descripcion: ", I.descripcion)
                    print("Retirado: ", I.retirado)
                    print("========================================")
                else:
                    print("========================================")
                    print("No se encontraron trabajos")
                    print("========================================")

    def salir(self):
        print("Gracias por utilizar el sistema.")
        sys.exit(0)
예제 #29
0
 def __init__(self):
     self.rt = RepositorioTrabajos()
예제 #30
0
파일: menu.py 프로젝트: brunoballi/TPFinal
class Menu:
    "Muestra ocpiones"

    def __init__(self):
        self.rc = RepositorioClientes()
        self.rt = RepositorioTrabajos()
        self.list_clientes = ListaClientes()
        self.listaTrabajo = ListaTrabajos()
        self.opciones = {
            "1": self.mostrar_clientes,
            "2": self.nuevo_cliente,
            "3": self.buscar_cliente,
            "4": self.modificar_datos_clientes,
            "5": self.borrar_cliente,
            "6": self.nuevo_trabajo,
            "7": self.mostrar_trabajos,
            "8": self.modificar_datos_trabajo,
            "9": self.finalizar_trabajo,
            "10": self.retirar_trabajo,
            "11": self.eliminar_trabajo,
            "12": self.historial_T,

            "0": self.salir
        }

    def mostrar_menu(self):
        print("""
Menú del sistema:
===================================================
- CLIENTES:                                                     
===================================================
1. Mostrar todos los clientes. 
2. Ingresar un nuevo cliente.                                       
3. Buscar un cliente.                                               
4. Modificar los datos de un cliente.                               
5. Eliminar un cliente.                                               
===================================================
- TRABAJOS:                                                                        
===================================================
6. Cargar nuevo trabajo.                                                                          
7. Mostrar todos los trabajos.
8. Modificar datos del trabajo.
9. Finalizar un trabajo.
10.Retirar un trabajo.
11.Eliminar un trabajo.
12.Ver Historial de trabajos de cada cliente.
===================================================
0. Salir del sistema
        """)

    def ejecutar(self):
        '''Mostrar el menu y responder a las opciones.
        '''
        while True:
            self.mostrar_menu()
            opcion = input("Ingresar una opción: ")
            accion = self.opciones.get(opcion)
            if accion:
                accion()
            else:
                print("{0} no es una opción válida".format(opcion))

    def mostrar_clientes(self):
        "Muestra todos los clientes"
        c = self.rc.get_all()
        if c:
            l = self.rc.get_all_corporativos()
            print("""         Clientes CORPORATIVOS:       """)
            if l:
                for i in l:
                    print("..................................................")
                    print(i)
                    print("..................................................")
            t = self.rc.get_all_particulares()

            print("""         Clientes PARTICULARES:        """)
            if t:
                for i in t:
                    print("..................................................")
                    print(i)
                    print("..................................................")
            input("\nPrecione 0 para volver al menu principal")
        else:
            print("\nNo hay cliente cargados en el sistema")
            input("\nPrecione 0 para volver al menu principal")

    def nuevo_cliente(self):
        "Ingresa un nuevo cliente, ya sea corporativo o particular"
        tipo = "A"
        while tipo not in ("C", "c", "P", "p"):
            tipo = input("Ingrese el tipo de Cliente: C:Corporativo / P:Particular")
        nombre = input("Ingrese el nombre: ")
        if tipo in ("C", "c"):
            nombre_contacto = input("Ingrese el nombre de contacto: ")
            telefono_contacto = input("Ingrese el telefono de contacto: ")
        else:
            apellido = input("Ingrese el apellido: ")
        telefono = input("Ingrese el numero de telefono: ")
        mail = input("Ingrese el correo electronico: ")
        if tipo in ("C", "c"):
            c = self.list_clientes.nuevo_cliente_corporativo(nombre, nombre_contacto, telefono_contacto, telefono, mail)
        else:
            c = self.list_clientes.nuevo_cliente_particular(nombre, apellido, telefono, mail)
        if c is None:
            print("Error al cargar cliente")
        else:
            print("Cliente cargado correctamente")

    def buscar_cliente(self):
        "Solicita un ID, busca al cliente con ese ID y lo muestra"
        c = self.rc.get_all()
        if c:
            while True:
                try:
                    id_cliente = int(input("Ingrese el ID del cliente que desea buscar: "))
                except ValueError:
                    print('Debe ingresar un numero')
                    continue
                break
            c = self.list_clientes._buscar_por_id(id_cliente)
            if c == None:
                print("El ID ingresado no pertenece a ningun cliente que este guardado en el sistema")
            else:
                print("\n................................................\n")
                print(c)
                print("..................................................")
            input("\nPrecione 0 para volver al menu principal")
        else:
            print("\nNo se encuentra ningun cliente particular que este guardado en el sistema")
            input("\nPrecione 0 para volver al menu principal")

    def modificar_datos_clientes(self):
        "Modificar los datos de un cliente, ya sea cliente corporativo o particular"
        tipo = "A"
        while tipo not in ("C", "c", "P", "p"):
            tipo = input("Ingrese el tipo de Cliente:  C:Corporativo / P:Particular")

        if tipo in ("C", "c"):
            l = self.rc.get_all_corporativos()
            if l:
                print("""         Clientes CORPORATIVOS           """)
                print("""-----------------------------------------""")
                for i in l:
                    print(i)
                    print("..................................................\n")
                    while True:
                        try:
                            id_cliente = int(input("Ingrese el ID del cliente: "))
                        except ValueError:
                            print('Debe ingresar un numero')
                            continue
                        break
                    cliente = self.list_clientes._buscar_por_id(id_cliente)
                    if cliente:
                        print(cliente)
                        print("Modifique el dato que desea: ")
                        print("..................................................\n")
                        nombre_empresa = input("Ingrese el nombre de la empresa: ")
                        nombre_contacto = input("Ingrese el nombre del contacto: ")
                        telefono_contacto = input("Ingrese el telefono del contacto: ")
                        telefono = input("Ingrese el telefono: ")
                        Mail = input("Ingrese el mail: ")
                        C = self.list_clientes.modificar_datos_CC(nombre_empresa, nombre_contacto, telefono_contacto,
                                                                  telefono, Mail, id_cliente)
                        if C == None:
                            print("Error al modificar los datos del cliente")
                            input("\nPrecione 0 para volver al menu principal")
                        else:
                            print("""Los datos fueron modificados con exito""")
                            print("\n................................................\n")
                            print(cliente)
                            print("..................................................")
                            input("\nPrecione 0 para volver al menu principal")
                    else:
                        print("\nEl ID ingresado no pertenece a ningun cliente corporativo que este guardado en el sistema")
                        input("\nPrecione 0 para volver al menu principal")
                else:
                    print("\nNo se encuentra ningun cliente corporativo que este guardado en el sistema")
                    input("\nPrecione 0 para volver al menu principal")
        else:
            l = self.rc.get_all_particulares()
            if l:
                print("""         Clientes PARTICULARES            """)
                print("""------------------------------------------""")
                for i in l:
                    print(i)
                    print("..................................................\n")
                while True:
                    try:
                        id_cliente = int(input("Ingrese el ID del cliente: "))
                    except ValueError:
                        print('Debe ingresar un numero')
                        continue
                    break
                cliente = self.list_clientes._buscar_por_id(id_cliente)
                if cliente:
                    print(cliente)
                    print("..................................................\n")

                    Nombre = input("Ingrese el nombre: ")
                    Apellido = input("Ingrese el apellido: ")
                    Tel = input("Ingrese el telefono: ")
                    Mail = input("Ingrese el mail: ")
                    C = self.list_clientes.modificar_datos_CP(Nombre, Apellido, Tel, Mail, id_cliente)
                    if C == None:
                        print("Error al modificar los datos del cliente")
                        input("\nPrecione 0 para volver al menu principal")
                    else:
                        print("Los datos fueron modificados con exito")
                        print(".................................................\n")
                        print(cliente)
                        print("..................................................")
                        input("\nPrecione 0 para volver al menu principal")
                else:
                    print("\nEl ID ingresado no pertenece a ningun cliente particular que este guardado en el sistema")
                    input("\nPrecione 0 para volver al menu principal")
            else:
                print("\nNo se encuentra ningun cliente particular que este guardado en el sistema")
                input("\nPrecione 0 para volver al menu principal")

    def borrar_cliente(self):
        "Solicita un ID y borra al cliente, en caso de que tenga trabajos pendientes, tambien los borra"
        b = self.rc.get_all_corporativos()
        if b:

            print("           Clientes CORPORATIVOS           ")
            print("-------------------------------------------")
            for i in b:
                print("ID cliente: ", i.id_cliente, "- Nombre: ", i.nombre_empresa)
                print("..................................................")
        t = self.rc.get_all_particulares()
        if t:
            print("""         CLIENTES PARTICULARES""")
            print("""-----------------------------------------""")
            for i in t:
                print("ID cliente: ", i.id_cliente, "- Nombre: ", i.nombre)
                print("..................................................\n")
        if b or t:
            while True:
                try:
                    id_cliente = int(input("Ingrese el ID del cliente: "))
                except ValueError:
                    print('Debe ingresar un numero')
                    continue
                break
            d = self.list_clientes._buscar_por_id(id_cliente)
            if d:
                print("\n..................................................\n")
                print(d)
                print("..................................................\n")
                f = "A"
                while f not in ("1", "2"):
                    f = input("""¿Seguro que desea eliminar al cliente? 
       1:Si Borrar.  / 2: No Borrar. 

       Ingrese una opcion: """)
                if f in ("1"):
                    a = self.list_clientes.eliminar_cliente(id_cliente)
                    if a == None:
                        print("Error al querer borrar al cliente")
                        print(".................................................")
                        input("\nPrecione 0 para volver al menu principal")
                    else:
                        print("El cliente fue eliminado con exito!")
                        print(".................................................")
                        input("\nPrecione 0 para volver al menu principal")

                else:
                    print("\nEl cliente no ha sido eliminado.")
                    input("\nPrecione 0 para volver al menu principal")
            else:
                print("\nEl ID ingresado no pertenece a ningun cliente que este guardado en el sistema")
                input("\nPrecione 0 para volver al menu principal")
        else:
            print("\nNo se encuentra ningun cliente que este guardado en el sistema")
            input("\nPrecione 0 para volver al menu principal")

    def nuevo_trabajo(self):
        "Solicita el ID de un cliente y carga los datos de un nuevo trabajo"
        b = self.rc.get_all_corporativos()
        if b:
            print("""         Clientes CORPORATIVOS          """)
            print("""-------------------------------------------""")
            for i in b:
                print("ID cliente: ", i.id_cliente, "- Nombre: ", i.nombre_empresa)
                print("............................................")
        t = self.rc.get_all_particulares()
        if t:
            print("""         Clientes PARTICULARES          """)
            print("""-------------------------------------------""")
            for i in t:
                print("ID cliente: ", i.id_cliente, "- Nombre: ", i.nombre)
                print(".............................................\n")
        if b or t:
            while True:
                try:
                    id_cliente = int(input("Ingrese el ID del cliente: "))
                except ValueError:
                    print('Debe ingresar un numero')
                    continue
                break
            C = self.list_clientes._buscar_por_id(id_cliente)
            if C == None:
                print("\nEl ID ingresado no pertenece a ningun cliente que este guardado en el sistema")
                input("\nPrecione 0 para volver al menu principal")
            else:
                fecha_ingreso = date.today()
                print("\nFecha de ingreso: ", fecha_ingreso)
                print("\nFecha de entrega propuesta: ")
                while True:
                    try:
                        dia = int(input("Ingrese el numero del dia: "))
                    except ValueError:
                        print("Debe ingresar un numero del 1 al 31")
                        continue
                    break
                while True:
                    try:
                        mes = int(input("Ingrese el numero del mes: "))
                    except ValueError:
                        print("Debe ingresar un numero del 1 al 12")
                        continue
                    break
                while True:
                    try:
                        anio = int(input("Ingrese el año: "))
                    except ValueError:
                        print("Debe ingresar un numero")
                        continue
                    break
                fecha_entrega_propuesta = date(anio, mes, dia)
                descripcion = input("\nIngrese descripcion del nuevo trabajo: ")
                t = self.listaTrabajo.nuevo_trabajo(C, fecha_ingreso, fecha_entrega_propuesta, descripcion)
                if t == None:
                    print("Error al cargar el nuevo trabajo")
                    print("..................................................")
                    input("\nPrecione 0 para volver al menu principal")

                else:
                    print("El nuevo trabajo se cargo con exito!\n")
                    print("-..................................................")
                    print(t)
                    print("..................................................\n")
                    input("\nPrecione 0 para volver al menu principal")
        else:
            print(
                "\nNo se encuentra ningun cliente que este guardado en el sistema")
            input("\nPrecione 0 para volver al menu principal")

    def mostrar_trabajos(self):
        "Muestra una lista con todos los trabajos"
        Lista = self.rt.get_all()
        if Lista:
            for Cliente in Lista:
                print(Cliente)
                print("..................................................")
        else:
            print("\nNo se encuentra ningun trabajo que este guardado en el sistema")
        input("\nPrecione 0 para volver al menu principal")

    def modificar_datos_trabajo(self):
        "Solicita un ID trabajo y modifica los datos del trabajo"
        t = self.rt.get_all()
        if t:
            for i in t:
                print("ID trabajo: ", i.id_trabajo)
                print("Fecha de ingreso: ", i.fecha_ingreso)
                print("Fecha entrega propuesta: ", i.fecha_entrega_propuesta)
                print("Descripcion: ", i.descripcion)
                print(".....................................................\n")
            while True:
                try:
                    id_trabajo = int(input("Ingrese el ID del trabajo: "))
                except ValueError:
                    print('Debe ingresar un numero')
                    continue
                break
            C = self.listaTrabajo._buscar_por_id(id_trabajo)
            if C == None:
                print("\nEl ID ingresado no pertenece a ningun trabajo que este guardado en el sistema")
                input("\nPrecione 0 para volver al menu principal")
            else:
                print(C.cliente)
                print("Trabajo:")
                print("Fecha de ingreso: ", C.fecha_ingreso)
                print("Fecha entrega propuesta: ", C.fecha_entrega_propuesta)
                print("Descripcion: ", C.descripcion)
                print("Modifique el dato que desea: ")
                print(".............................................................")
                tipo = "A"
                while tipo not in ("1", "2", "3", "4"):
                    while tipo not in ("4"):
                        tipo = input("""\n¿Desea hacer alguna modificacion?

       1: Fecha de ingreso / 2: Fecha entrega propuesta / 3: Descripcion / 4: Salir

       Ingrese una opcion: """)
                        if tipo in ("1"):
                            print("Modificar fecha de ingreso\n")
                            while True:
                                try:
                                    dia = int(input("Ingrese el numero del dia: "))
                                except ValueError:
                                    print('Debe ingresar un numero del 1 al 31')
                                    continue
                                break
                            while True:
                                try:
                                    mes = int(input("Ingrese el numero del mes: "))
                                except ValueError:
                                    print('Debe ingresar un numero del 1 al 12')
                                    continue
                                break
                            while True:
                                try:
                                    anio = int(input("Ingrese el año: "))
                                except ValueError:
                                    print('Debe ingresar un numero')
                                    continue
                                break
                            FechaIngreso = date(anio, mes, dia)
                            t = self.listaTrabajo.modificar_datos_trabajo(FechaIngreso, C.fecha_entrega_real,
                                                                          C.descripcion,
                                                                          id_trabajo)
                            if t == None:
                                print("Error al modificar el trabajo")
                                print("..................................................")
                                input("\nPrecione 0 para volver al menu principal")
                            else:
                                print("\n..................................................")
                                print("Los datos fueron modificados con exito!")
                                print("..................................................\n")
                                print(C)
                                print("..................................................")
                        if tipo in ("2"):
                            print("Modificar fecha de entregra propuesta\n")
                            while True:
                                try:
                                    dia = int(input("Ingrese el numero del dia: "))
                                except ValueError:
                                    print('Debe ingresar un numero del 1 al 31')
                                    continue
                                break
                            while True:
                                try:
                                    mes = int(input("Ingrese el numero del mes: "))
                                except ValueError:
                                    print('Debe ingresar un numero del 1 al 12')
                                    continue
                                break
                            while True:
                                try:
                                    anio = int(input("Ingrese el año: "))
                                except ValueError:
                                    print('Debe ingresar un numero')
                                    continue
                                break
                            FechaEntregaPropuesta = date(anio, mes, dia)
                            t = self.listaTrabajo.modificar_datos_trabajo(C.fecha_ingreso, FechaEntregaPropuesta,
                                                                          C.descripcion,
                                                                          id_trabajo)
                            if t == None:
                                print("Error al modificar el trabajo")
                                print("..................................................")
                                input("\nPrecione 0 para volver al menu principal")
                            else:
                                print("\n................................................")
                                print("Los datos fueron modificados con exito!")
                                print(".................................................\n")
                                print(C)
                                print("..................................................")
                        if tipo in ("3"):
                            print("..................................................")
                            print("Modificar la descripcion del trabajo\n")
                            Descripcion = input("Ingrese la descripcion del trabajo: ")
                            T = self.listaTrabajo.modificar_datos_trabajo(C.fecha_ingreso, C.fecha_entrega_real,
                                                                          Descripcion,
                                                                          id_trabajo)
                            if T == None:
                                print("..................................................")
                                print("Error al modificar el trabajo")
                                print("..................................................")
                                input("\nPrecione 0 para volver al menu principal")
                            else:
                                print("\n..................................................")
                                print("Los datos fueron modificados con exito!")
                                print("..................................................\n")
                                print(C)
                                print("..................................................")
                    if tipo in ("4"):
                        self.ejecutar()
        else:
            print("\nNo se encuentra ningun trabajo que este guardado en el sistema")
            input("\nPrecione 0 para volver al menu principal")

    def finalizar_trabajo(self):
        "Solicita un ID trabajo y modifica la fecha de entrega real"
        t = self.rt.get_all()
        if t:
            for i in t:
                print(i.cliente)
                print("ID trabajo: ", i.id_trabajo, "- Fecha entrega real: ", i.fecha_entrega_real)
                print("..................................................")
            while True:
                try:
                    id_trabajo = int(input("Ingrese el ID del trabajo: "))
                except ValueError:
                    print('Debe ingresar un numero')
                    continue
                break
            C = self.listaTrabajo._buscar_por_id(id_trabajo)
            if C == None:
                print("\nEl ID ingresado no pertenece a ningun trabajo que este guardado en el sistema")
                input("\nPrecione 0 para volver al menu principal")
            else:
                if C.fecha_entrega_real:
                    print("El estado del trabajo se encuentra como finalizado")
                    input("\nPrecione 0 para volver al menu principal")
                else:
                    print(C)
                    print("..................................................")
                    tipo = "A"
                    while tipo not in ("1", "2"):
                        tipo = input("""¿Desea finalizar el trabajo?
       1: Si Finalizar. / 2: No Finalizar.

       Ingresa una opcion: """)
                    if tipo in ("1"):
                        t = self.listaTrabajo.trabajo_finalizado(id_trabajo)
                        if t == None:
                            print("Error al modificar la entrega del trabajo")
                            print("..................................................")
                            input("\nPrecione 0 para volver al menu principal")
                        else:
                            print("\nEl trabajo fue finalizado con exito!")
                            print(C)
                            print("..................................................")
                            input("\nPrecione 0 para volver al menu principal")
                    else:
                        print("No se realizo modificacion en la finalizacion del trabajo")
                        print("..................................................\n")
                        input("\nPrecione 0 para volver al menu principal")
        else:
            print("\nNo se encuentra ningun trabajo que este cargado en el sistema")
            input("\nPrecione 0 para volver al menu principal")

    def retirar_trabajo(self):
        "Solicita un ID trabajo y lo marca como retirado"
        t = self.rt.get_all()
        if t:
            for i in t:
                print("\n.......................................................")
                print(i.cliente)
                print("ID trabajo: ", i.id_trabajo, "- Retirado: ", i.retirado)
                print("........................................................\n")
            while True:
                try:
                    id_trabajo = int(input("Ingrese el ID del trabajo: "))
                except ValueError:
                    print('Debe ingresar un numero')
                    continue
                break
            C = self.listaTrabajo._buscar_por_id(id_trabajo)
            if C == None:
                print("\nEl ID ingresado no pertenece a ningun trabajo que este guardado en el sistema")
                input("\nPrecione 0 para volver al menu principal")
            else:
                if C.retirado == True:
                    print("\nEl trabajo ya se encuentra como retirado")
                    input("\nPrecione 0 para volver al menu principal")
                else:
                    print("\n.....................................................")
                    print(C)
                    print(".......................................................")
                    tipo = "A"
                    while tipo not in ("1", "2"):
                        print("\n..................................................")
                        tipo = input("""¿Desea dar por retirado el trabajo?

       1: Si Retirar. / 2: No Retirar.

       Ingresa una opcion: """)
                    if tipo in ("1"):
                        T = self.listaTrabajo.retiro_trabajo(id_trabajo)
                        if T == None:
                            print("Error al retirar el trabajo")
                            print(".....................................................")
                            input("\nPrecione 0 para volver al menu principal")
                        else:
                            print("El trabajo fue retirado con exito!")
                            print("...................................................\n")
                            print(C)
                            print("\n...................................................")
                            input("\nPrecione 0 para volver al menu principal")
                    else:
                        print("No se realizo modificacion en el retiro del trabajo")
                        print(".........................................................")
                        input("\nPrecione 0 para volver al menu principal")
        else:
            print("\nNo se encuentra ningun trabajo que este guardado en el sistema")
            input("\nPrecione 0 para volver al menu principal")

    def eliminar_trabajo(self):
        "Solicita un ID trabajo y borra un trabajo"
        t = self.rt.get_all()
        if t:
            for i in t:
                print("ID trabajo: ", i.id_trabajo)
                print("Fecha de ingreso: ", i.fecha_ingreso)
                print("Fecha entrega propuesta: ", i.fecha_entrega_propuesta)
                print("Fecha de entrega real: ", i.fecha_entrega_real)
                print("Descripcion: ", i.descripcion)
                print("Retirado: ", i.retirado)
                print(".......................................................\n")
            while True:
                try:
                    id_trabajo = int(input("Ingrese el ID del trabajo: "))
                except ValueError:
                    print('Debe ingresar un numero')
                    continue
                break
            C = self.listaTrabajo._buscar_por_id(id_trabajo)
            if C == None:
                print("\nEl ID ingresado no pertenece a ningun trabajo que este guardado en el sistema")
                input("\nPrecione 0 para volver al menu principal")
            else:
                print("\n.................................................")
                print(C)
                print("..................................................\n")
                tipo = "A"
                while tipo not in ("1", "2"):
                    tipo = input("""¿Seguro que desea eliminar el trabajo?

       1: Si Eliminar. / 2: No Eliminar.

       Ingresa una opcion: """)
                if tipo in ("1"):
                    t = self.listaTrabajo.eliminar_trabajo(id_trabajo)
                    if t == None:
                        print("Error al eliminar el trabajo")
                        print("...........................................")
                        input("\nPrecione 0 para volver al menu principal")

                    else:
                        print("El trabajo fue eliminado con exito!")
                        print("............................................")
                        input("\nPrecione 0 para volver al menu principal")
                else:
                    print("El trabajo no se ha eliminado")
                    print("................................................")
                    input("\nPrecione 0 para volver al menu principal")
        else:
            print("\nNo se encuentra ningun trabajo que este guardado en el sistema")
            input("\nPrecione 0 para volver al menu principal")

        # HISTORIAL DE TRABAJOS de cada Cliente:

    def historial_T(self):
        """Solicita un ID y muestra una lista con los trabajos encargados por el cliente"""
        l = self.rc.get_all_corporativos()
        if l:
            print("""         CLIENTES CORPORATIVOS""")
            for i in l:
                print("...........................................................")
                print("ID cliente: ", i.id_cliente, "- Nombre: ", i.nombre_empresa)
                print("...........................................................")
        t = self.rc.get_all_particulares()
        if t:
            print("""         CLIENTES PARTICULARES""")
            for i in t:
                print("............................................................")
                print("ID cliente: ", i.id_cliente, "- Nombre: ", i.nombre)
                print("..........................................................\n")
        if l or t:
            while True:
                try:
                    id = int(input("\nIngrese el ID del cliente: "))
                except ValueError:
                    print('Debe ingresar un numero')
                    continue
                break
            C = self.list_clientes._buscar_por_id(id)
            if C == None:
                print("\nEl ID ingresado no pertenece a ningun cliente que este guardado en el sistema")
                input("\nPrecione 0 para volver al menu principal")
            else:
                print(C)
                print("...............................................................")
                t = self.listaTrabajo.listaTrabajo
                if t:
                    for U in t:
                        if U.cliente.id_cliente == id:
                            print("...................................................\n")
                            print("ID trabajo: ", U.id_trabajo)
                            print("Fecha de ingreso: ", U.fecha_ingreso)
                            print("Fecha entrega propuesta: ", U.fecha_entrega_propuesta)
                            print("Fecha entrega real: ", U.fecha_entrega_real)
                            print("Descripcion: ", U.descripcion)
                            print("Retirado: ", U.retirado)
                            print("......................................................")
                    input("\nPrecione 0 para volver al menu principal")
                else:
                    print("\nEl cliente no tiene ningun trabajo que este guardado en el sistema")
                    input("\nPrecione 0 para volver al menu principal")
        else:
            print("\nNo se encuentra ningun cliente que este guardado en el sistema")
            input("\nPrecione 0 para volver al menu principal")

    def salir(self):
        """Sale del sistema"""
        print("¡Gracias por utilizar el sistema!.")
        sys.exit(0)