Пример #1
0
 def __init__(self):
     '''crea una lisata de clientes '''
     self.repositorio = Repositorio()
     self.clientes = []
     try:
         self.clientes = self.repositorio.get_all_clientes()
     except Exception as mensaje:
         raise
Пример #2
0
 def __init__(self): 
     self.repositorio=Repositorio()
     self.pedidos=[]
     self.estados=["Recibido","Presupuestado","Reparado","Entregado","Pagado"]
     try:
         self.pedidos=self.repositorio.get_all_pedidos()    
     except Exception as mensaje:
         raise
Пример #3
0
class Anotador:
    '''Representa una colección de Notas que se pueden etiquetar, modificar, y
    buscar'''
    def __init__(self):
        '''Inicializa el anotador con una lista vacía de Notas'''
        self.repositorio = Repositorio()
        self.notas = self.repositorio.get_all()

    def nueva_nota(self, texto, etiquetas=''):
        '''Crea una nueva nota y la agrega a la lista'''
        nota = Nota(texto, etiquetas)
        nota.id = self.repositorio.guardar(nota)
        self.notas.append(nota)
        return nota

    def _buscar_por_id(self, id_nota):
        '''Buscar la nota con el id dado'''
        for nota in self.notas:
            if str(nota.id) == str(id_nota):
                return nota
        return None

    def modificar_nota(self, id_nota, texto):
        '''Busca la nota con el id dado y modifica el texto'''
        nota = self._buscar_por_id(id_nota)
        if nota:
            nota.texto = texto
            self.repositorio.actualizar(nota)
            return True
        return False

    def modificar_etiquetas(self, id_nota, etiquetas):
        '''Busca la nota con el id dado y modifica las etiquetas'''
        nota = self._buscar_por_id(id_nota)
        if nota:
            nota.etiquetas = etiquetas
            self.repositorio.actualizar(nota)
            return True
        return False

    def buscar(self, filtro):
        '''Busca todas las notas que coincidan con el filtro dado'''
        return [nota for nota in self.notas if nota.coincide(filtro)]

    def eliminar_nota(self, id_nota):
        '''Busca la nota con el id dado y la elimina de la lista notas'''
        nota = self._buscar_por_id(id_nota)
        if nota:
            self.notas.remove(nota)
            self.repositorio.eliminar(nota)
            return True
        return False
Пример #4
0
class Clientes:
    '''Contiene una lista de clientes self.clientes, permite agregar o quitar'''
    def __init__(self):
        '''crea una lisata de clientes '''
        self.repositorio = Repositorio()
        self.clientes = []
        try:
            self.clientes = self.repositorio.get_all_clientes()
        except Exception as mensaje:
            raise

    def agregar_cliente(self, nombre, apellido, domicilio, telefono, mail):
        '''guarda un cliente nuevo'''
        cliente = Contacto(nombre, apellido, domicilio, telefono, mail)
        cliente.id = self.repositorio.guardar_cliente(cliente)
        self.clientes.append(cliente)
        print(cliente.id, cliente.nombre, cliente.mail)

        return cliente

    def eliminar_cliente(self, id_cliente):
        cliente = self.buscar_cliente_por_id(id_cliente)
        if cliente:
            self.clientes.remove(cliente)
            self.repositorio.eliminar(cliente)

        else:
            return "cliente no encontrado"

    def buscar_cliente_por_id(self, n_cliente):
        ''' busca el cliente con el id dado y lo retorna'''
        for contacto in self.clientes:
            if str(contacto.id) == str(n_cliente):
                return contacto

    def buscar_cliente(self, filtro):
        '''recibe un filtro y hace la busqueda sobre nombre'''
        lista = []
        for cliente in self.clientes:
            print(cliente.id)
            if (str(cliente.nombre) == str(filtro)) or (str(
                    cliente.apellido) == str(filtro)) or (str(cliente.mail)
                                                          == str(filtro)):
                lista.append(cliente)
        return lista

    def modificar_cliente(self, id, nombre, apellido, domicilio, telefono,
                          mail):
        cliente = self.buscar_cliente_por_id(id)
        print(id)
        if cliente:
            cliente.nombre = nombre
            cliente.apellido = apellido
            cliente.domicilio = domicilio
            cliente.telefono = telefono
            cliente.mail = mail
            self.repositorio.actualizar(cliente)
            return cliente
Пример #5
0
class Repositorio_Turno:
    ###Consulta y guarda turnos en la BD###

    def __init__(self):
        self.bd = sqlite3.connect("turnos.db")
        self.cursor = self.bd.cursor()
        self.rp = Repositorio()

    def get_all(self):
        ###Retorna una lista de objetos Turno con todos los turnos que haya guardados en la BD###
        lista_turnos = []
        consulta = "SELECT id, descripcion,  fecha_creacion, fecha_turno, hora, id_paciente FROM turnos;"
        self.cursor.execute(consulta)
        todos_los_turnos = self.cursor.fetchall()
        for id, descripcion, fecha_creacion, fecha_turno, hora, id_paciente in todos_los_turnos:
            paciente = self.rp.get_one(id_paciente)
            lista_turnos.append(
                Turno(paciente, fecha_turno, hora, descripcion, id))
        return lista_turnos

    def guardar(self, turnos):
        ###Guarda el turno en la BD### #probar y revisar!!! #ver que onda id_paciente
        consulta = "INSERT INTO turnos (descripcion,  fecha_creacion, fecha_turno, hora, id_paciente) VALUES (?, ?, ?, ?, ?);"  # 29/10 agregado id_paciente
        resultado = self.cursor.execute(consulta, [
            turnos.descripcion, turnos.fecha_creacion, turnos.fecha_turno,
            turnos.hora, turnos.id_paciente
        ])
        id_turnos = resultado.lastrowid
        self.bd.commit()
        return id_turnos

    def actualizar(self, turnos):
        ###Actualiza el turno en la BD### #ver que onda " paciente = ? "
        consulta = "UPDATE turnos SET fecha_turno = ?, hora = ?, descripcion = ? WHERE id = ?;"
        self.cursor.execute(
            consulta,
            [turnos.fecha_turno, turnos.hora, turnos.descripcion, turnos.id
             ])  # 29/10 eliminado turnos.paciente
        self.bd.commit()

    def eliminar(self, turnos):
        ###Elimina el turno de la BD###
        print(turnos.id)
        consulta = "DELETE FROM turnos WHERE id = ?;"
        self.cursor.execute(consulta, [turnos.id])
        self.bd.commit()
Пример #6
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
     }
from repositorio import Repositorio

from databases import PostgresDB, MysqlDB

db_conn_postgres = PostgresDB()
db_conn_mysql = MysqlDB()
repo = Repositorio()

repo.insert(db_conn_postgres)
print()
repo.insert(db_conn_mysql)

Пример #8
0
 def __init__(self):
     self.bd = sqlite3.connect("turnos.db")
     self.cursor = self.bd.cursor()
     self.rp = Repositorio()
Пример #9
0
    print(msg)
    sys.exit(1)

if __name__ == '__main__':
    parser = argparse.ArgumentParser(description="""For getting and dumping data
                                                  into the db""")
    parser.add_argument("--get", dest="get", help="""This option is used to
    obtain data of the db, you have to pass the filename""")
    parser.add_argument("--get-lineal-r", dest="get_lineal", help="""This
    option is used to obtain the values of lineal regression of the db,
    you have to pass the filename""")
    parser.add_argument("--put", dest="put", help="""This is for dump values
    into the db, you have to pass the filename or a path""")
    args = parser.parse_args()

    myDB = Repositorio(MYDB)
    if args.get:
        if path.isfile(args.get):
            #its a file not just a part of the name
            values = myDB.get_original_data(args.get)
            x_processed_values, y_processed_values = myDB.get_processed_data(args.get)
            print x_values, y_values
        else:
            #its a RE
            descriptions = myDB.get_filenames_with_re(args.get)
            x_values = []; y_values = []
            x_total_proc_values = []; y_total_proc_values = []

            for d in descriptions:
                values = myDB.get_original_data(d)
                x_values += values[0]
Пример #10
0
 def __init__(self):
     self.r = Repositorio()
     self.pacientes = self.r.get_all()
     #self.pacientes = []
     self.turnos = []
Пример #11
0
 def __init__(self):
     '''Inicializa el anotador con una lista vacía de Notas'''
     self.repositorio = Repositorio()
     self.notas = self.repositorio.get_all()
Пример #12
0
 def __init__(self):
     self.r = Repositorio()
     self.rt = Repositorio_Turno()
     self.pacientes = self.r.get_all()
     self.turnos = self.rt.get_all()
Пример #13
0
class Gestion:
    def __init__(self):
        self.r = Repositorio()
        self.rt = Repositorio_Turno()
        self.pacientes = self.r.get_all()
        self.turnos = self.rt.get_all()

    def nuevo_paciente(self, apellido, nombre, dni, telefono, mail):
        paciente = Paciente(apellido, nombre, dni, telefono, mail)
        paciente.id = self.r.guardar(paciente)
        #self.pacientes.append(paciente)
        return paciente

    def _buscar_por_id(self, id_paciente):
        for paciente in self.pacientes:
            if str(paciente.id) == str(id_paciente):
                return paciente
        return None

    def modificar_paciente(self, id_paciente, apellido, nombre, dni, telefono,
                           mail):
        paciente = self._buscar_por_id(id_paciente)
        if paciente:
            paciente.apellido = apellido
            paciente.nombre = nombre
            paciente.dni = dni
            paciente.telefono = telefono
            paciente.mail = mail
            self.r.actualizar(paciente)
            return True
        return False

    def eliminar_paciente(self, id_paciente):
        paciente = self._buscar_por_id(id_paciente)
        if paciente:
            self.r.eliminar(paciente)
            return True
        return False

    def _buscar_turno_id(self, id_turno):
        for turno in self.turnos:
            if str(turno.id) == str(id_turno):
                return turno
        return None

    def asignar_turno(self, id_paciente, fecha_turno, hora, descripcion):
        paciente = self._buscar_por_id(id_paciente)
        turno = Turno(paciente, fecha_turno, hora, descripcion)
        turno.id = self.rt.guardar(turno)
        return turno

    def eliminar_turno(self, id_turno):
        turno = self._buscar_turno_id(id_turno)
        if turno:
            self.rt.eliminar(turno)
            return True
        return False

    def modificar_turno(self, id_turno, fecha_turno, hora, descripcion):
        turno = self._buscar_turno_id(id_turno)
        if turno:
            turno.fecha_turno = fecha_turno
            turno.hora = hora
            turno.descripcion = descripcion
            self.rt.actualizar(turno)
            #self.turnos.append(turno) #29/10 eliminado, corrigió error al actualizar el treeview
            return True
        return False

    def turnos_dia(self, filtro):
        return [turno for turno in self.turnos if turno.busqueda(filtro)]
Пример #14
0
    """Plot chart of x_values vs. y_values using color and label."""
    data, = pylab.plot(y_values)
    pylab.legend()
    pylab.title(title)
    pylab.text(400, -0.0002, about, {'color': 'g', 'fontsize': 15})
    pylab.xlabel('x')
    pylab.ylabel('y')
    pylab.savefig("../plots/matplot2std.png", dpi = 100)


if __name__ == '__main__':
    
    parser = argparse.ArgumentParser(description='For test linealregression and standar desviation')
    parser.add_argument("-f", "--file", dest="file", help='This option is used to pass the data file')
    args = parser.parse_args()    
    myDB = Repositorio(MYDB)
    #nos aseguramos de guardar en la db el archivo

    values = myDB.insert_data(args.file)
    #obtain de std of y values
    desviation_y = do_std(values[1])
    
    #dump into the db
    myDB.dump_data(args.file, [None], [desviation_y], "std")
    plot_data(values[1],  r'$\sigma = %.18f $' %(desviation_y), "y_values and std")
    
    #do the same with lineal regression 
    results_lineal = do_linealregression(values[0], values[1])
    labels = ['slope', 'intercept', 'r_value', 'p_value']

    for value, about in zip(results_lineal, labels):
 def get_random_palabra(self):
     return Repositorio.falta_palabra(self)
Пример #16
0
class Pedidos:
    ''' Almacena cada pedido de trabajo'''

    def __init__(self): 
        self.repositorio=Repositorio()
        self.pedidos=[]
        self.estados=["Recibido","Presupuestado","Reparado","Entregado","Pagado"]
        try:
            self.pedidos=self.repositorio.get_all_pedidos()    
        except Exception as mensaje:
            raise
    def nuevo_pedido(self, id_cliente, descripcion, etiquetas=' ', fecha_prev=' ', fecha_entrega=' ',
                 id_estado=' ',precio=' ',pagado=' '):    
        obj=Pedido(id_cliente, descripcion, etiquetas, fecha_prev, fecha_entrega,
                 id_estado,precio,pagado)
        ret=self.pegar_estado(obj)
        id=self.repositorio.guardar_pedido(ret)
        ret.id_pedido=id
        self.pedidos.append(ret)
        
        return ret
    def buscar_pedido(self,filtro):
        lista=[]
        for i in self.pedidos:
            if ( str(filtro) in str(i.descripcion)) or (str(i.etiquetas) == str(filtro)) or (str(i.id_pedido)==str(filtro)):
                lista.append(i)
        return lista        
        
    def buscar_por_id(self,id_pedido):
        for pedido in self.pedidos:
            if str(pedido.id_pedido)==str(id_pedido):
                return pedido
    def entregar_pedido(self,id_pedido):
        pedido=self.buscar_por_id(id_pedido)
        if pedido:
            pedido.id_estado=self.estados[3]
            pedido.fecha_entrega=datetime.today()
            self.repositorio.actualizar_pedido(pedido)
            return pedido
        else:
            return 'Nose encontro pedido'
    def modificar_pedido(self,id_pedido, descripcion=' ', precio=' ',etiquetas='', pagado=''):
        pedido=self.buscar_por_id(id_pedido)
            
        if pedido:
            if descripcion:
                pedido.descripcion=descripcion
            if precio:
                pedido.precio=precio
            if etiquetas:
                pedido.etiquetas=etiquetas
            if pagado:
                pedido.pagado=pagado
            self.pegar_estado(pedido)
            self.repositorio.actualizar_pedido(pedido)
        else:
            return 'pedido no encontrado'

    def pedidos_por_vencer(self):
            '''recibe un número "n" como parámetro, y retorna una lista de
                los contactos que cumplen años en los próximos "n" días.'''
            lista=[]
            pedidos=[]
            for y in self.pedidos:
                pedidos.append(y)
            contador=0
            formato=("%d/%m/%Y")
            n=int(5)
            fecha_busqueda=datetime.today()
            while contador < n:
                contador +=1   
                for xx in pedidos:
                    x=xx.fecha_prev
                    x=datetime.strptime(xx.fecha_prev,formato)
                    resultado=x-fecha_busqueda
                    print(x)
                    print(resultado)
                    if (int(resultado.days) < 5) and (int(resultado.days) > 0):
                        lista.append(xx)
                    pedidos.remove(xx)
                fecha_busqueda = fecha_busqueda + timedelta(days=1)
                print(fecha_busqueda)
                
            return lista
    def pedidos_vencidos(self):
            lista=[]
            pedidos=[]
            for y in self.pedidos:
                pedidos.append(y)
            contador=0
            formato=("%d/%m/%Y")
            n=int(5)
            fecha_busqueda=datetime.today()
            
            for xx in pedidos:
                x=xx.fecha_prev
                x=datetime.strptime(x,formato)
                print(x)
                resultado=x-fecha_busqueda
                if int(resultado.days)<0:
                    lista.append(xx)
                pedidos.remove(xx)
            return lista
    def pegar_estado(self,pedido):
        if pedido:
            pedido.id_estado=self.estados[0]
        if pedido.precio:   
            if int(pedido.precio) > 0:
                pedido.id_estado=self.estados[1]
        if pedido.precio == pedido.pagado:
            pedido.id_estado=self.estados[4]
        return pedido
    def eliminar_elpedido(self,id_pedido):
        pedido=self.buscar_por_id(id_pedido)
        if pedido:
            self.pedidos.remove(pedido)
            self.repositorio.eliminar_pedido_bd(pedido)
Пример #17
0
class Gestion:
    def __init__(self):
        self.r = Repositorio()
        self.pacientes = self.r.get_all()
        #self.pacientes = []
        self.turnos = []

    def nuevo_paciente(self, apellido, nombre, dni, telefono, mail):
        paciente = Paciente(apellido, nombre, dni, telefono, mail)
        self.r.guardar(paciente)
        #self.pacientes.append(paciente)
        return paciente

    def _buscar_por_id(self, id_paciente):
        for paciente in self.pacientes:
            if str(paciente.id) == str(id_paciente):
                return paciente
        return None

    def modificar_paciente(self, id_paciente, apellido, nombre, dni, telefono,
                           mail):
        paciente = self._buscar_por_id(id_paciente)
        if paciente:
            paciente.apellido = apellido
            paciente.nombre = nombre
            paciente.dni = dni
            paciente.telefono = telefono
            paciente.mail = mail
            self.r.actualizar(paciente)  # !!
            return True
        return False

    def eliminar_paciente(self, id_paciente):
        paciente = self._buscar_por_id(id_paciente)
        if paciente:
            self.r.eliminar(paciente)
            #self.pacientes.remove(paciente)
            return True
        return False

    def _buscar_turno_id(self, id_turno):
        for turno in self.turnos:
            if str(turno.id_t) == str(id_turno):
                return paciente
        return None

    def asignar_turno(self, id_paciente, fecha_turno, hora, descripcion):
        paciente = self._buscar_por_id(id_paciente)
        turno = self.asignar_turno(paciente, fecha_turno, hora, descripcion)
        self.turnos.append(turno)

    def eliminar_turno(self, id_paciente):
        if turno:
            self.turnos.remove(turno)
            return True
        return False

    def modificar_turno(self, id_paciente, fecha_turno, hora, descripcion):
        paciente = self._buscar_por_id(id_paciente)
        if turno:
            turno.fecha_turno = fecha_turno
            turno.hora = hora
            turno.descripcion = descripcion
            return True
        return False