def main():
task_ids = {}
for key in model_dict.keys():
task_ids[key] = set([
item[0] for item in db().query(Task.id).filter(Task.type_==key)]
)
model_ids = {}
for key, model in model_dict.items():
model_ids[key] = set([item[0] for item in db().query(model.id)])
for key in model_dict.keys():
print(task_ids[key].difference(model_ids[key]))
def upgrade():
from sqlalchemy import Date, cast
from datetime import date
from autonomie.models.task.invoice import Payment
from autonomie_base.models.base import DBSESSION as db
for payment in db().query(Payment).filter(cast(Payment.created_at, Date) == date.today()):
try:
payment.remittance_amount = float(payment.remittance_amount) / 100000.0
db().merge(payment)
except:
print(u"Erreur payment : %s (%s)" % (payment.id, payment.remittance_amount))
from zope.sqlalchemy import mark_changed
mark_changed(db())
def upgrade():
from sqlalchemy import Date, cast
from datetime import date
from autonomie.models.task.invoice import Payment
from autonomie_base.models.base import DBSESSION as db
for payment in db().query(Payment).filter(cast(Payment.created_at, Date) == date.today()):
try:
payment.amount = payment.amount/1000
db().merge(payment)
except:
print(u"Erreur payment : %s (%s)" % payment.id, payment.amount)
from zope.sqlalchemy import mark_changed
mark_changed(db())
def export_task_totals(arguments, env):
action = get_value(arguments, 'a')
if action == "check":
check_totals(arguments, env)
return
print(arguments)
logger = logging.getLogger(__name__)
filename = get_value(arguments, 'f')
if filename:
print("Generating a csv filename %s" % filename)
gen_csv(filename)
if action == 'cache':
print(u"Caching amounts")
session = db()
index = 0
for task in Task.query().filter(
Task.type_.in_(['invoice', 'estimation', 'cancelinvoice'])):
try:
cache_amounts(None, None, task)
session.merge(task)
index += 1
if index % 50 == 0:
print('flushing')
session.flush()
except:
logger.exception(u"Erreur avec un cache_amount : %s" % task.id)
def export_task_totals(arguments, env):
action = get_value(arguments, 'a')
if action == "check":
check_totals(arguments, env)
return
print(arguments)
logger = logging.getLogger(__name__)
filename = get_value(arguments, 'f')
if filename:
print("Generating a csv filename %s" % filename)
gen_csv(filename)
if action == 'cache':
print(u"Caching amounts")
session = db()
index = 0
for task in Task.query().filter(
Task.type_.in_(['invoice', 'estimation', 'cancelinvoice'])
):
try:
cache_amounts(None, None, task)
session.merge(task)
index += 1
if index % 50 == 0:
print('flushing')
session.flush()
except:
logger.exception(
u"Erreur avec un cache_amount : %s" % task.id
)
def refresh_cache(arguments, env):
logger = logging.getLogger(__name__)
if not arguments['refresh']:
logger.exception(u"Unknown error")
logger.debug(u"Refreshing cache")
session = db()
index = 0
types = get_value(arguments, '--type')
if types is None:
types = ['invoice', 'estimation', 'cancelinvoice']
this_year = datetime.date.today().year
for task in Task.query().filter(
Task.type_.in_(types)
).filter(extract('year', Task.date) == this_year):
try:
cache_amounts(None, None, task)
session.merge(task)
index += 1
if index % 200 == 0:
logger.debug('flushing')
session.flush()
except:
logger.exception(u"Error while caching total : {0}".format(task.id))
def upgrade():
from autonomie.models.task import Payment
from autonomie_base.models.base import DBSESSION as db
table = Payment.__tablename__
op.execute("Alter table {table} CHANGE amount amount BIGINT(20)".format(
table=table))
for entry in db().query(Payment.id, Payment.amount,
Payment.remittance_amount):
id_, amount, remittance = entry
query = "update {table} set amount={amount}, remittance_amount={remittance} where id={id}".format(
table=table,
amount=amount * 1000,
remittance=format_remittance(remittance),
id=id_,
)
op.execute(query)
from zope.sqlalchemy import mark_changed
mark_changed(db())
def upgrade():
from autonomie.models.task import Payment
from autonomie_base.models.base import DBSESSION as db
table = Payment.__tablename__
op.execute(
"Alter table {table} CHANGE amount amount BIGINT(20)".format(
table=table
)
)
for entry in db().query(Payment.id, Payment.amount, Payment.remittance_amount):
id_, amount, remittance = entry
query = "update {table} set amount={amount}, remittance_amount={remittance} where id={id}".format(
table=table,
amount=amount*1000,
remittance=format_remittance(remittance),
id=id_,
)
op.execute(query)
from zope.sqlalchemy import mark_changed
mark_changed(db())
def upgrade():
from autonomie.models.task import (
DiscountLine,
TaskLine,
Task,
PaymentLine,
)
from autonomie.models.treasury import TurnoverProjection
from autonomie_base.models.base import DBSESSION as db
models = (
(DiscountLine, ("amount",),),
(TaskLine, ("cost",),),
(Task, ('ht', 'tva', 'ttc', 'expenses_ht', 'expenses', ),),
(PaymentLine, ('amount',),),
(TurnoverProjection, ('value',),),
)
for model, keys in models:
for key in keys:
op.execute(
u"Alter table {table} CHANGE {key} {key} BIGINT(20)".format(
table=model.__tablename__, key=key
)
)
for model, keys in models:
attrs = [getattr(model, 'id')]
attrs.extend([getattr(model, key) for key in keys])
query = db().query(*attrs)
if model == Task:
query = query.filter(
Task.type_.in_(('invoice', 'estimation', 'cancelinvoice'))
)
for entry in query:
id_ = entry[0]
vals = entry[1:]
f_keys = ["%s=%s" % (keys[index], 1000 * value)
for index, value in enumerate(vals)
if value is not None]
key_query = ','.join(f_keys)
if key_query.strip():
query = "update {table} set {key_query} where id={id}".format(
table=model.__tablename__,
key_query=key_query,
id=id_
)
op.execute(query)
def upgrade():
from autonomie.models.task import (
DiscountLine,
TaskLine,
Task,
PaymentLine,
)
from autonomie.models.treasury import TurnoverProjection
from autonomie_base.models.base import DBSESSION as db
models = (
(
DiscountLine,
("amount", ),
),
(
TaskLine,
("cost", ),
),
(
Task,
(
'ht',
'tva',
'ttc',
'expenses_ht',
'expenses',
),
),
(
PaymentLine,
('amount', ),
),
(
TurnoverProjection,
('value', ),
),
)
for model, keys in models:
for key in keys:
op.execute(
u"Alter table {table} CHANGE {key} {key} BIGINT(20)".format(
table=model.__tablename__, key=key))
for model, keys in models:
attrs = [getattr(model, 'id')]
attrs.extend([getattr(model, key) for key in keys])
query = db().query(*attrs)
if model == Task:
query = query.filter(
Task.type_.in_(('invoice', 'estimation', 'cancelinvoice')))
for entry in query:
id_ = entry[0]
vals = entry[1:]
f_keys = [
"%s=%s" % (keys[index], 1000 * value)
for index, value in enumerate(vals) if value is not None
]
key_query = ','.join(f_keys)
if key_query.strip():
query = "update {table} set {key_query} where id={id}".format(
table=model.__tablename__, key_query=key_query, id=id_)
op.execute(query)
def query_tasks():
tasks = db().query(Task.id, Task.ht, Task.tva, Task.ttc)
return tasks
def query_tasks():
tasks = db().query(Task.id, Task.ht, Task.tva, Task.ttc)
return tasks