def get_scheme(table):
sql = """SELECT COLUMN_NAME
FROM INFORMATION_SCHEMA.COLUMNS
WHERE TABLE_SCHEMA = '{}'
AND TABLE_NAME = '{}'
""".format(DB_NAME, table)
return DBQuery().execute(sql)
def insert(self):
sql = """
INSERT INTO cliente
(denominacion, nif, domicilio)
VALUES ('{}', '{}', {})
""".format(self.denominacion, self.nif, self.domicilio.domicilio_id)
self.cliente_id = DBQuery().execute(sql)
def select(self):
clase = self.__class__.__name__.lower()
propiedad_id = '{}_id'.format(clase)
propiedades = vars(self)
campos_tabla = []
for campo in propiedades:
if not isinstance(propiedades[campo], list):
campos_tabla.append(campo)
sql = "SELECT {cp} FROM {c} WHERE {c}_id = {pi}".format(
cp=", ".join(campos_tabla),
c=clase,
pi=self.__dict__[propiedad_id])
resultados = DBQuery(db_data).execute(sql)[0]
for i, p in enumerate(propiedades.keys()):
compositor = "{}".format(p.capitalize())
compositor_id = '{}_id'.format(p)
archivo = "modules.{}".format(p)
if self.__dict__[p] is None:
modulo = __import__(archivo, fromlist=[compositor])
self.__dict__[p] = getattr(modulo, compositor)() # FACTORY?
self.__dict__[p].__dict__[compositor_id] = resultados[i]
self.__dict__[p].select()
elif isinstance(self.__dict__[p], list):
pass
# identificar dependientes e independientes y construirlas
# según el conector lógico o el get auxiliar
else:
self.__dict__[p] = resultados[i]
def insert(self):
sql = """
INSERT INTO datodecontacto
(denominacion, valor, cliente)
VALUES ('{}', '{}', {})
""".format(self.denominacion, self.valor, self.cliente)
self.datodecontacto_id = DBQuery(db_data).execute(sql)
def delete(self):
sql = """DELETE FROM {compositor}{compuesto}
WHERE compuesto = {pi}""".format(
compositor=self._compositor,
compuesto=self._clase_compuesto,
pi=self.compuesto.__dict__[self._propiedad_id_compuesto])
DBQuery().execute(sql)
def update(self):
sql = """
UPDATE cliente
SET denominacion = '{}', nif = '{}', domicilio = {}
WHERE cliente_id = {}
""".format(self.denominacion, self.nif, self.domicilio.domicilio_id,
self.cliente_id)
DBQuery(db_data).execute(sql)
def update(self):
sql = """
UPDATE domicilio
SET calle = '{}', numero = '{}', planta = {}, puerta = '{}', ciudad = '{}'
WHERE domicilio_id = {}
""".format(self.calle, self.numero, self.planta, self.puerta,
self.ciudad, self.domicilio_id)
DBQuery(db_data).execute(sql)
def insert(self):
sql = """
insert into domicilio
(calle, numero, planta, puerta, ciudad)
values ('{}', '{}', {}, '{}', '{}')
""".format(self.calle, self.numero, self.planta, self.puerta,
self.ciudad)
self.domicilio_id = DBQuery(db_data).execute(sql)
def update(self):
sql = """
UPDATE datodecontacto
SET denominacion = "{}",
valor = "{}"
WHERE datodecontacto_id = {}
""".format(self.denominacion, self.valor, self.datodecontacto_id)
DBQuery().execute(sql)
def update(self):
sql = """
UPDATE producto
SET denominacion = '{}',
precio = {}
WHERE producto_id = {}
""".format(self.denominacion, self.precio, self.producto_id)
DBQuery().execute(sql)
def update(self):
sql = """
UDPATE datodecontacto
SET denominacion = '{}', valor = '{}', cliente = {}
WHERE datodecontacto_id = {}
""".format(self.denominacion, self.valor, self.cliente,
self.datodecontacto_id)
DBQuery(db_data).execute(sql)
def insert(self):
sql = """
INSERT INTO producto
(denominacion, precio)
VALUES
('{}', {})
""".format(self.denominacion, self.precio)
self.producto_id = DBQuery().execute(sql)
def insert(self):
sql = """INSERT INTO task (title, description, done, useraccess)
VALUES ('{title}', '{description}', {done}, '{useraccess}')
""".format(title=self.title,
description=self.description,
doen=self.done,
useraccess=self.useraccess.useraccess_id)
self.task_id = DBQuery().execute(sql)
def insert(self):
sql = """
INSERT INTO domicilio
(numero, puerta, calle, piso, ciudad, cp)
VALUES
("{}", "{}", "{}", {}, "{}", "{}")
""".format(self.numero, self.puerta, self.calle, self.piso,
self.ciudad, self.cp)
self.domicilio_id = DBQuery().execute(sql)
def select(self):
sql = """
SELECT denominacion, precio
FROM producto
WHERE producto_id = {}
""".format(self.producto_id)
resultado = DBQuery().execute(sql)[0]
self.denominacion = resultado[0]
self.precio = resultado[1]
def select(self):
sql = """
SELECT denominacion, valor
FROM datodecontacto
WHERE datodecontacto_id = {}
""".format(self.datodecontacto_id)
resultado = DBQuery().execute(sql)[0]
self.denominacion = resultado[0]
self.valor = resultado[1]
def select(self):
sql = """
SELECT denominacion, valor, cliente
FROM datodecontacto
WHERE datodecontacto_id = {}
""".format(self.datodecontacto_id)
resultados = DBQuery(db_data).execute(sql)[0]
self.denominacion = resultados[0]
self.valor = resultados[1]
self.cliente = resultados[2]
def delete(self):
class_name = self.__class__.__name__
class_name = class_name.lower()
id_value = getattr(self, '{}_id'.format(class_name))
sql = """
DELETE
FROM {}
WHERE {}_id = {}
""".format(class_name, class_name, id_value)
DBQuery(db_data).execute(sql)
def select(self):
sql = """
SELECT denomination, level
FROM user
WHERE user_id = '{}'
""".format(self.user_id)
resultados = DBQuery(db_data).execute(sql)[0]
self.denomination = resultados[0]
self.level = resultados[1]
def get(self):
sql = "SELECT pedido_id FROM pedido"
pedidos = DBQuery(db_data).execute(sql)
for p in pedidos:
pedido = Pedido()
pedido.pedido_id = p[0]
pedido.producto_collection = []
pedido.select()
self.coleccion.append(pedido)
def insert(self):
sql = """
INSERT INTO pedido
(estado, fecha, cliente)
VALUES ({}, '{}', {})
""".format(
self.estado,
self.fecha,
self.cliente
)
self.pedido_id = DBQuery().execute(sql)
def select(self):
sql = """SELECT title, description, done, useraccess
FROM task
WHERE task_id = {id}
""".format(id=self.task_id)
data = DBQuery().execute(sql)[0]
# propiedades simples
self.title = data[0]
self.description = data[1]
self.useraccess = make(Useraccess, data[3])
def get(self, clase):
sql = "SELECT {c}_id FROM {c}".format(c=clase.lower())
pids = DBQuery(db_data).execute(sql)
modulo = __import__(PACKAGE, fromlist=[clase])
for pid in pids:
modelo = getattr(modulo, clase)()
vars(modelo)["{}_id".format(clase.lower())] = pid[0]
modelo.select()
self.coleccion.append(modelo)
def insert(self):
sql = """
INSERT INTO user
(user_id, denomination, level)
VALUES ('{}', '{}', {})
""".format(
self.user_id,
self.denomination,
self.level
)
DBQuery(db_data).execute(sql)
def update(self):
sql = """UPDATE task
SET title = '{title}',
description = '{description}',
done = {done},
useraccess = '{useraccess}'
WHERE task_id = {id}
""".format(title=self.title,
description=self.description,
done=self.done,
useraccess=self.useraccess)
DBQuery().execute(sql)
def update(self):
sql = """
UPDATE pedido
SET estado = {}, fecha = '{}', cliente = {}
WHERE pedido_id = {}
""".format(
self.estado,
self.fecha,
self.cliente,
self.pedido_id
)
DBQuery(db_data).execute(sql)
def get(self, clase):
cls_lower = clase.lower()
sql = "SELECT {cls}_id FROM {cls}".format(cls=cls_lower)
resultados = DBQuery().execute(sql)
exec "from modules.{} import {}".format(cls_lower, clase)
for tupla in resultados:
exec "obj = {}()".format(clase)
exec "obj.{}_id = tupla[0]".format(cls_lower)
obj.select()
self.coleccion.append(obj)
def update(self):
sql = """
UPDATE domicilio
SET numero = "{}",
puerta = "{}",
calle = "{}",
piso = {},
ciudad = "{}",
cp = "{}"
WHERE domicilio_id ={}
""".format(self.numero, self.puerta, self.calle, self.piso,
self.ciudad, self.cp, self.domicilio_id)
DBQuery().execute(sql)
def get(self, cls_name):
table = cls_name.lower()
sql = "SELECT {}_id FROM {}".format(table, table)
rows = DBQuery().execute(sql)
exec("from modules.{} import {}".format(table, cls_name))
for row in rows:
obj = locals()[cls_name]()
exec("obj.{}_id = '{}'".format(table, row[0]))
obj.select()
self.add_obj(obj)
return self.collection
def select(self):
sql = """
SELECT numero , puerta, calle, piso, ciudad, cp
FROM domicilio
WHERE domicilio_id = {}
""".format(self.domicilio_id)
resultado = DBQuery().execute(sql)[0]
self.numero = resultado[0]
self.puerta = resultado[1]
self.calle = resultado[2]
self.piso = resultado[3]
self.ciudad = resultado[4]
self.cp = resultado[5]
