def stoccaggio_table(soup=None, op=None,dao=None, row=None, all=False):
d = None
if soup and not all:
record = soup.stoccaggio.get(loads(row.object))
else:
record = row
if op =="DELETE":
if all:
d = Stoccaggio().getRecord(id=row.id)
else:
d = Stoccaggio().getRecord(id=loads(row.object))
if d:
d.delete()
return True
elif op == "INSERT":
if all:
d = Stoccaggio()
d.id = record.id
else:
d = Stoccaggio().getRecord(id=loads(row.object))
elif op == "UPDATE":
if all:
d = Stoccaggio().getRecord(id=row.id)
else:
d = Stoccaggio().getRecord(id=loads(row.object))
d.scorta_minima= record.scorta_minima
d.livello_riordino = record.livello_riordino
d.data_fine_scorte =record.data_fine_scorte
d.data_prossimo_ordine = record.data_prossimo_ordine
d.id_articolo = record.id_articolo
d.id_magazzino = record.id_magazzino
d.persist()
return True
def sconti_vendita_dettaglio_table(soup=None, op=None, dao=None,rowLocale=None, row=None, all=False):
d = None
if soup and not all:
record = soup.sconti_vendita_dettaglio.get(loads(row.object))
else:
record = row
if op =="DELETE":
if all:
d = ScontoVenditaDettaglio().getRecord(id=row.id)
else:
d = ScontoVenditaDettaglio().getRecord(id=loads(row.object))
if d:
d.delete()
return True
elif op == "INSERT":
if all:
d = ScontoVenditaDettaglio()
d.id = record.id
else:
d = ScontoVenditaDettaglio().getRecord(id=loads(row.object))
elif op == "UPDATE":
if all:
d = ScontoVenditaDettaglio().getRecord(id=row.id)
else:
d = ScontoVenditaDettaglio().getRecord(id=loads(row.object))
if not d:
d = ScontoVenditaDettaglio()
d.id = record.id
d.id_listino = record.id_listino
d.id_articolo = record.id_articolo
d.data_listino_articolo = record.data_listino_articolo
d.persist()
return True
def fornitore_table(soup=None, op=None,dao=None, row=None, all=False):
d = None
if soup and not all:
record = soup.fornitore.get(loads(row.object))
else:
record = row
if op =="DELETE":
if all:
d = Fornitore().getRecord(id=row.id)
else:
d = Fornitore().getRecord(id=loads(row.object))
if d:
d.delete()
return True
elif op == "INSERT":
if all:
d = Fornitore()
d.id = record.id
else:
d = Fornitore().getRecord(id=loads(row.object))
elif op == "UPDATE":
if all:
d = Fornitore().getRecord(id=row.id)
else:
d = Fornitore().getRecord(id=loads(row.object))
d.id_categoria_fornitore = record.id_categoria_fornitore
d.id_pagamento = record.id_pagamento
d.id_magazzino = record.id_magazzino
d.persist()
return True
def test_query(self):
q = Session.query(User).filter(User.name == "ed").options(eagerload(User.addresses))
eq_(q.all(), [User(name="ed", addresses=[Address(id=2), Address(id=3), Address(id=4)])])
q2 = serializer.loads(serializer.dumps(q, -1), users.metadata, Session)
def go():
eq_(q2.all(), [User(name="ed", addresses=[Address(id=2), Address(id=3), Address(id=4)])])
self.assert_sql_count(testing.db, go, 1)
eq_(q2.join(User.addresses).filter(Address.email == "*****@*****.**").value(func.count("*")), 1)
u1 = Session.query(User).get(8)
q = Session.query(Address).filter(Address.user == u1).order_by(desc(Address.email))
q2 = serializer.loads(serializer.dumps(q, -1), users.metadata, Session)
eq_(q2.all(), [Address(email="*****@*****.**"), Address(email="*****@*****.**"), Address(email="*****@*****.**")])
q = Session.query(User).join(User.addresses).filter(Address.email.like("%fred%"))
q2 = serializer.loads(serializer.dumps(q, -1), users.metadata, Session)
eq_(q2.all(), [User(name="fred")])
eq_(list(q2.values(User.id, User.name)), [(9, u"fred")])
def test_query_one(self):
q = Session.query(User).\
filter(User.name == 'ed').\
options(joinedload(User.addresses))
q2 = serializer.loads(
serializer.dumps(q, -1),
users.metadata, Session)
def go():
eq_(q2.all(), [
User(name='ed', addresses=[Address(id=2),
Address(id=3), Address(id=4)])])
self.assert_sql_count(testing.db, go, 1)
eq_(q2.join(User.addresses).filter(Address.email
== '*****@*****.**').value(func.count('*')), 1)
u1 = Session.query(User).get(8)
q = Session.query(Address).filter(Address.user
== u1).order_by(desc(Address.email))
q2 = serializer.loads(serializer.dumps(q, -1), users.metadata,
Session)
eq_(q2.all(), [Address(email='*****@*****.**'),
Address(email='*****@*****.**'),
Address(email='*****@*****.**')])
def categoria_cliente_table(soup=None, op=None, dao=None, row=None, all=False):
d = None
if soup and not all:
record = soup.categoria_cliente.get(loads(row.object))
else:
record = row
if op =="DELETE":
if all:
d = CategoriaCliente().getRecord(id=row.id)
else:
d = CategoriaCliente().getRecord(id=loads(row.object))
if d:
d.delete()
return True
elif op == "INSERT":
if all:
d = CategoriaCliente()
d.id = record.id
else:
d = CategoriaCliente().getRecord(id=loads(row.object))
elif op == "UPDATE":
if all:
d = CategoriaCliente().getRecord(id=row.id)
else:
d = CategoriaCliente().getRecord(id=loads(row.object))
d.descrizione = record.descrizione
d.denominazione= record.denominazione
d.active= record.active
d.persist()
return True
def sconto_table(soup=None, op=None, dao=None,rowLocale=None, row=None, all=False):
d = None
if soup and not all:
record = soup.sconto.get(loads(row.object))
else:
record = row
if op =="DELETE":
if all:
d = Sconto().getRecord(id=row.id)
else:
d = Sconto().getRecord(id=loads(row.object))
if d:
d.delete()
return True
elif op == "INSERT":
if all:
d = Sconto()
d.id = record.id
else:
d = Sconto().getRecord(id=loads(row.object))
elif op == "UPDATE":
if all:
d = Sconto().getRecord(id=row.id)
else:
d = Sconto().getRecord(id=loads(row.object))
if not d:
d = Sconto()
d.id = record.id
d.valore = record.valore
d.tipo_sconto= record.tipo_sconto
d.persist()
return True
def codice_a_barre_articolo_table(soup=None, op=None, dao=None, row=None, all=False):
d = None
if soup and not all:
record = soup.codice_a_barre_articolo.get(loads(row.object))
else:
record = row
if op =="DELETE":
if all:
d = CodiceABarreArticolo().getRecord(id=row.id)
else:
d = CodiceABarreArticolo().getRecord(id=loads(row.object))
if d:
d.delete()
return True
elif op == "INSERT":
if all:
d = CodiceABarreArticolo()
d.id = record.id
else:
d = CodiceABarreArticolo().getRecord(id=loads(row.object))
elif op == "UPDATE":
if all:
d = CodiceABarreArticolo().getRecord(id=row.id)
else:
d = CodiceABarreArticolo().getRecord(id=loads(row.object))
if not d:
d = CodiceABarreArticolo()
d.id = record.id
d.codice = record.codice
d.id_articolo = record.id_articolo
d.primario = record.primario
d.persist()
return True
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.drop_all(engine)
Base.metadata.create_all(engine)
# delete_all()
with transaction.manager:
f = open("./db_backup.txt", 'r');
serialized_data = pickle.load(f)
serialized_menu_items = serialized_data["menu_items"]
menu_items = loads(serialized_menu_items, Base.metadata, DBSession)
print menu_items
print "hello"
for menu_item in menu_items:
DBSession.merge(menu_item)
print 'menu_item is %r'%menu_item
print "hello done"
serialized_allergens = serialized_data["allergens"]
allergens = loads(serialized_allergens, Base.metadata, DBSession)
for allergen in allergens:
DBSession.merge(allergen)
serialized_menus = serialized_data["menus"]
menus = loads(serialized_menus, Base.metadata, DBSession)
for menu in menus:
DBSession.merge(menu)
def listino_table(soup=None, op=None, dao=None, row=None, all=False):
d = None
if soup and not all:
record = soup.listino.get(loads(row.object))
else:
record = row
if op =="DELETE":
if all:
d = Listino().getRecord(id=[row.denominazione,row.data_listino])
else:
d = Listino().getRecord(id=loads(row.object))
if d:
d.delete()
return True
elif op == "INSERT":
if all:
d = Listino()
d.id = record.id
else:
d = Listino().getRecord(id=loads(row.object))
elif op == "UPDATE":
if all:
d = Listino().select(id=row.id)
if d:
d = d[0]
else:
d = Listino().getRecord(id=loads(row.object))
d.denominazione = record.denominazione
d.descrizione = record.descrizione
d.data_listino= record.data_listino
d.listino_attuale = record.listino_attuale
d.visible= record.visible
d.persist()
return True
def listino_magazzino_table(soup=None, op=None, dao=None, row=None,all=False):
d = None
if soup and not all:
record = soup.listino_magazzino.get(loads(row.object))
else:
record = row
if op =="DELETE":
if all:
d = ListinoMagazzino().getRecord(id=[row.id_listino,row.id_magazzino])
else:
d = ListinoMagazzino().getRecord(id=loads(row.object))
if d:
d.delete()
return True
elif op == "INSERT":
if all:
d = ListinoMagazzino()
d.id_listino = record.id_listino
d.id_magazzino = record.id_magazzino
else:
d = ListinoArticolo().getRecord(id=loads(row.object))
elif op == "UPDATE":
if all:
d = ListinoArticolo().getRecord(id=[row.id_listino,row.id_magazzino])
#if d:
#d = d[0]
else:
d = ListinoArticolo().getRecord(id=loads(row.object))
d.persist()
return True
def test_annotated_one(self):
j = join(users, addresses)._annotate({"foo": "bar"})
query = select([addresses]).select_from(
j
)
str(query)
for prot in pickle_protocols():
pickled_failing = serializer.dumps(
j, prot)
serializer.loads(pickled_failing, users.metadata, None)
def listino_articolo_table(soup=None, op=None, dao=None, rowLocale=None, row=None, all=False):
d = None
if soup and not all:
record = soup.listino_articolo.get(loads(row.object))
else:
record = row
if op == "DELETE":
if all:
d = ListinoArticolo().getRecord(id=[row.id_articolo, row.id_listino, row.data_listino_articolo])
else:
d = ListinoArticolo().getRecord(id=loads(row.object))
if d:
d.delete()
return True
elif op == "INSERT":
if all:
d = ListinoArticolo()
d.id_listino = record.id_listino
d.id_articolo = record.id_articolo
d.data_listino_articolo = record.data_listino_articolo
else:
d = ListinoArticolo().getRecord(id=loads(row.object))
elif op == "UPDATE":
if all:
# d = ListinoArticolo().getRecord(id=[row.id_articolo,row.id_listino,row.data_listino_articolo])
d = (
Environment.params["session"]
.query(ListinoArticolo)
.get((row.id_articolo, row.id_listino, row.data_listino_articolo))
)
else:
d = ListinoArticolo().getRecord(id=loads(row.object))
if not d:
d = ListinoArticolo()
d.id_listino = record.id_listino
d.id_articolo = record.id_articolo
d.data_listino_articolo = record.data_listino_articolo
d.prezzo_dettaglio = record.prezzo_dettaglio
d.prezzo_ingrosso = record.prezzo_ingrosso
d.ultimo_costo = record.ultimo_costo
d.listino_attuale = record.listino_attuale
a = d.persist()
if not a:
# g = ListinoArticolo().select(codice=record.codice)
# if g :
# g=g[0]
# g.codice = g.codice+"BIS"
# b = g.persist()
# if not b:
print "PROPRIO NON SO COSA FARE HO ANCHE CAMBIATO IL CODICE"
# listino_articolo_table(soup=soup, op=op, dao=dao, row=row, all=all)
return True
def test_query_two(self):
q = Session.query(User).join(User.addresses).\
filter(Address.email.like('%fred%'))
q2 = serializer.loads(serializer.dumps(q, -1), users.metadata,
Session)
eq_(q2.all(), [User(name='fred')])
eq_(list(q2.values(User.id, User.name)), [(9, 'fred')])
def test_expression(self):
expr = select([users]).select_from(users.join(addresses)).limit(5)
re_expr = serializer.loads(serializer.dumps(expr, -1), users.metadata, None)
eq_(str(expr), str(re_expr))
assert re_expr.bind is testing.db
eq_(re_expr.execute().fetchall(), [(7, u"jack"), (8, u"ed"), (8, u"ed"), (8, u"ed"), (9, u"fred")])
def test_aliases(self):
u7, u8, u9, u10 = Session.query(User).order_by(User.id).all()
ualias = aliased(User)
q = Session.query(User, ualias).join((ualias, User.id < ualias.id)).filter(User.id<9).order_by(User.id, ualias.id)
q2 = serializer.loads(serializer.dumps(q), users.metadata, Session)
eq_(list(q2.all()), [(u7, u8), (u7, u9), (u7, u10), (u8, u9), (u8, u10)])
def test_orm_join(self):
from sqlalchemy.orm.util import join
j = join(User, Address, User.addresses)
j2 = serializer.loads(serializer.dumps(j, -1), users.metadata)
assert j2.left is j.left
assert j2.right is j.right
assert j2._target_adapter._next
def fornitura_table(soup=None, op=None,dao=None, row=None, all=False):
d = None
if soup and not all:
record = soup.fornitura.get(loads(row.object))
else:
record = row
if op =="DELETE":
if all:
d = Fornitura().getRecord(id=row.id)
else:
d = Fornitura().getRecord(id=loads(row.object))
if d:
d.delete()
return True
elif op == "INSERT":
if all:
d = Fornitura()
d.id = record.id
else:
d = Fornitura().getRecord(id=loads(row.object))
elif op == "UPDATE":
if all:
d = Fornitura().getRecord(id=row.id)
else:
d = Fornitura().getRecord(id=loads(row.object))
d.codice_articolo_fornitore = record.codice_articolo_fornitore
d.prezzo_lordo = record.prezzo_lordo
d.prezzo_netto = record.prezzo_netto
d.applicazione_sconti = record.applicazione_sconti
d.scorta_minima = record.scorta_minima
d.tempo_arrivo_merce = record.tempo_arrivo_merce
d.fornitore_preferenziale = record.fornitore_preferenziale
d.percentuale_iva = record.percentuale_iva
d.data_fornitura = record.data_fornitura
d.data_prezzo = record.data_prezzo
d.id_fornitore = record.id_fornitore
d.id_articolo = record.id_articolo
d.id_multiplo = record.id_multiplo
d.persist()
return True
def test_query_three(self):
ua = aliased(User)
q = \
Session.query(ua).join(ua.addresses).\
filter(Address.email.like('%fred%'))
q2 = serializer.loads(serializer.dumps(q, -1), users.metadata,
Session)
eq_(q2.all(), [User(name='fred')])
# try to pull out the aliased entity here...
ua_2 = q2._entities[0].entity_zero.entity
eq_(list(q2.values(ua_2.id, ua_2.name)), [(9, 'fred')])
def test_unicode(self):
m = MetaData()
t = Table(ue('\u6e2c\u8a66'), m,
Column(ue('\u6e2c\u8a66_id'), Integer))
expr = select([t]).where(t.c[ue('\u6e2c\u8a66_id')] == 5)
expr2 = serializer.loads(serializer.dumps(expr, -1), m)
self.assert_compile(
expr2,
ue('SELECT "\u6e2c\u8a66"."\u6e2c\u8a66_id" FROM "\u6e2c\u8a66" '
'WHERE "\u6e2c\u8a66"."\u6e2c\u8a66_id" = :\u6e2c\u8a66_id_1'),
dialect="default"
)
def initdata(source='data/serialized_dump.txt'):
print("Start importing data")
with open(source, 'rb') as f:
data = json.loads(f.readline())
for model_data in data:
try:
restored = loads(model_data, db.metadata, db.session)
except AttributeError, e:
print('Table does not exist: {}'.format(e))
continue
if restored:
print('Importing {} table...'.format(restored[0].__table__.name))
for item in restored:
db.session.merge(item)
db.session.commit()
def restore_everything(session, backupdict):
meta = get_declarative_base().metadata
# Truncate tables
progress = QtGui.QProgressDialog()
progress.show()
progress.setAutoClose(True)
progress.setLabelText("Tömmer databas")
progress.setMaximum(len(meta.sorted_tables) + 1)
for table in reversed(meta.sorted_tables):
session.execute(table.delete())
session.commit()
session.close()
progress.setLabelText("Återställer")
# Add recovered objects
for i, table in enumerate(meta.sorted_tables):
progress.setValue(i + 1)
if progress.wasCanceled():
return False
if table.name in backupdict:
progress.setLabelText('Återställer tabellen %s' % table.name)
QtCore.QCoreApplication.processEvents()
serialized_table = backupdict[table.name]
restored_objects = loads(serialized_table, meta, session)
for restored_object in restored_objects:
table_class = table.name.replace("Table", "")
if (table_class == "MembershipType"):
table_class = "Membership"
if (table_class == 'members_sequence'):
table_class = "Sequence"
row = eval(table_class)()
i = 0
for key in restored_object.keys():
setattr(row, key, restored_object[i])
i += 1
session.merge(row)
session.commit()
session.close()
progress.close()
return True
def test_attribute(self):
assert serializer.loads(serializer.dumps(User.name), None, None) is User.name
def test_columns(self):
assert serializer.loads(serializer.dumps(users.c.name), users.metadata, Session) is users.c.name
def test_mapper(self):
user_mapper = class_mapper(User)
assert serializer.loads(serializer.dumps(user_mapper), None, None) is user_mapper
def test_any(self):
r = User.addresses.any(Address.email=='x')
ser = serializer.dumps(r)
x = serializer.loads(ser, users.metadata)
eq_(str(r), str(x))
def test_tables(self):
assert serializer.loads(serializer.dumps(users), users.metadata, Session) is users
def test_columns(self):
assert serializer.loads(serializer.dumps(users.c.name), users.metadata,
Session) is users.c.name
def test_tables(self):
assert serializer.loads(serializer.dumps(users), users.metadata,
Session) is users
def test_attribute(self):
assert serializer.loads(serializer.dumps(User.name), None,
None) is User.name
def test_mapper(self):
user_mapper = class_mapper(User)
assert serializer.loads(serializer.dumps(user_mapper), None,
None) is user_mapper
def get_object(self):
return loads(self.pickle)
def deserialize(cls: Type[T], string: str) -> T:
return loads(string.encode())
def parse_data(self, contents):
"""Loads a dump and convert it into rows """
db = self.db()
return loads(contents, db.metadata, db.session)
def test_any(self):
r = User.addresses.any(Address.email == 'x')
ser = serializer.dumps(r, -1)
x = serializer.loads(ser, users.metadata)
eq_(str(r), str(x))
def unpickle_pickle(self):
self.expression = loads(self.expr_blob, t_m_Base.metadata, Session)
def parse_data(self, contents):
"""Loads a dump and convert it into rows """
db = self.db()
return loads(contents, db.metadata, db.session)
def fetch_from_cache(self):
record = self.recorder.load_record(self.cache_key)
cached_value = sa_serializer.loads(base64.b64decode(record["data"]))
return self.merge_result(cached_value, load=False)
def articolo_table(soup=None, op=None, dao=None, row=None, all=False):
d = None
if soup and not all:
record = soup.articolo.get(loads(row.object))
else:
record = row
if op == "DELETE":
if all:
d = Articolo().getRecord(id=row.id)
else:
d = Articolo().getRecord(id=loads(row.object))
if d:
d.delete()
return True
elif op == "INSERT":
if all:
d = Articolo()
d.id = record.id
else:
d = Articolo().getRecord(id=loads(row.object))
elif op == "UPDATE":
if all:
d = Articolo().getRecord(id=row.id)
else:
d = Articolo().getRecord(id=loads(row.object))
if not d:
d = Articolo()
d.id = record.id
d.codice = record.codice
d.denominazione = record.denominazione
d.id_aliquota_iva = record.id_aliquota_iva
d.id_famiglia_articolo = record.id_famiglia_articolo
d.id_categoria_articolo = record.id_categoria_articolo
d.id_immagine = record.id_immagine
d.id_unita_base = record.id_unita_base
d.id_stato_articolo = record.id_stato_articolo
d.produttore = record.produttore
d.unita_dimensioni = record.unita_dimensioni
d.lunghezza = record.lunghezza
d.larghezza = record.larghezza
d.altezza = record.altezza
d.unita_volume = record.unita_volume
d.volume = record.volume
d.unita_peso = record.unita_peso
d.peso_lordo = record.peso_lordo
d.id_imballaggio = record.id_imballaggio
d.peso_imballaggio = record.peso_imballaggio
d.stampa_etichetta = record.stampa_etichetta
d.codice_etichetta = record.codice_etichetta
d.descrizione_etichetta = record.descrizione_etichetta
d.stampa_listino = record.stampa_listino
d.descrizione_listino = record.descrizione_listino
d.aggiornamento_listino_auto = record.aggiornamento_listino_auto
d.timestamp_variazione = record.timestamp_variazione
d.note = record.note
d.contenuto = record.contenuto
d.cancellato = record.cancellato
d.sospeso = record.sospeso
d.quantita_minima = record.quantita_minima
a = d.persist()
if not a:
g = Articolo().select(codice=record.codice)
if g:
g = g[0]
g.codice = g.codice + "BIS"
b = g.persist()
if not b:
print "PROPRIO NON SO COSA FARE HO ANCHE CAMBIATO IL CODICE"
articolo_table(soup=soup, op=op, dao=dao, row=row, all=all)
return True
def test_query_two(self):
q = (Session.query(User).join(User.addresses).filter(
Address.email.like("%fred%")))
q2 = serializer.loads(serializer.dumps(q, -1), users.metadata, Session)
eq_(q2.all(), [User(name="fred")])
eq_(list(q2.with_entities(User.id, User.name)), [(9, "fred")])
