def _add_business_to_all_invoices(session):
"""
Add a Business entry to all invoices
"""
from autonomie.models.task import (
Estimation, Invoice,
)
logger.debug(u"Adding business to estimations")
eindex = 0
iindex = 0
for e in Estimation.query().options(
sa.orm.load_only('id', 'name', 'business_type_id', 'project_id')
):
eindex += 1
invoices = Invoice.query().options(
sa.orm.load_only('id')
).filter_by(estimation_id=e.id).all()
if invoices:
business = e.gen_business()
for deadline in business.payment_deadlines:
deadline.invoiced = True
session.merge(deadline)
for invoice in invoices:
iindex += 1
op.execute(
u"update task set business_id=%s where id=%s" % (
business.id,
invoice.id
)
)
op.execute(
u"update task join cancelinvoice as c on c.id=task.id "
u"set task.business_id=%s where c.invoice_id=%s" % (
business.id,
invoice.id
)
)
logger.debug(" + %s estimations treated" % eindex)
logger.debug(" + %s invoices treated" % iindex)
logger.debug(u"Adding business to direct invoices")
iindex = 0
for invoice in Invoice.query().options(
sa.orm.load_only('id', 'name', 'business_type_id', 'project_id')
).filter_by(estimation_id=None):
iindex += 1
business = invoice.gen_business()
op.execute(
u"update task join cancelinvoice as c on c.id=task.id "
u"set task.business_id=%s where c.invoice_id=%s" % (
business.id,
invoice.id
)
)
logger.debug(" + %s invoices treated" % iindex)
session.flush()
def upgrade():
logger = logging.getLogger("alembic.add_compte_cg")
op.add_column("tva", sa.Column("compte_cg", sa.String(125), default=""))
op.add_column("tva", sa.Column("code", sa.String(125), default=""))
op.add_column("company", sa.Column("contribution", sa.Integer))
op.add_column("customer",
sa.Column("compte_cg", sa.String(125), default=""))
op.add_column("customer",
sa.Column("compte_tiers", sa.String(125), default=""))
# Ajout du code produit au ligne des factures et avoirs
for table in ("invoice_line", "cancelinvoice_line"):
op.add_column(table,
sa.Column("product_id", sa.Integer, default=""))
# Ajout d'un tag "exporte" aux factures et avoirs
for table in ("invoice", "cancelinvoice"):
op.add_column(table,
sa.Column("exported",
sa.Boolean()))
# Les factures et avoirs deja validees sont considerees comme exportees
logger.warn(u"On tag des factures comme exportees")
for invoice in Invoice.query():
if invoice.CAEStatus in Invoice.valid_states:
invoice.exported = True
DBSESSION().merge(invoice)
logger.warn(u"officialNumber : {0.officialNumber} \
{0.financial_year}".format(invoice))
for cinv in CancelInvoice.query():
if cinv.CAEStatus in CancelInvoice.valid_states:
cinv.exported = True
DBSESSION().merge(cinv)
logger.warn(u"officialNumber : {0.officialNumber} \
{0.financial_year}".format(cinv))
def test_gen_invoice(self):
user = self.session.query(User).first()
customer = self.session.query(Customer).first()
project = self.session.query(Project).first()
phase = self.session.query(Phase).first()
est = self.getOne()
est.phase = phase
est.project = project
est.owner = user
est.customer = customer
est.statusPersonAccount = user
invoices = est.gen_invoices(user)
for inv in invoices:
self.session.add(inv)
self.session.flush()
invoices = Invoice.query().filter(Invoice.estimation_id==est.id).all()
#deposit :
deposit = invoices[0]
self.assertEqual(deposit.taskDate, datetime.date.today())
self.assertEqual(deposit.financial_year, datetime.date.today().year)
self.assertEqual(deposit.total(), est.deposit_amount_ttc())
#intermediate invoices:
intermediate_invoices = invoices[1:-1]
for index, line in enumerate(PAYMENT_LINES[:-1]):
inv = intermediate_invoices[index]
# Here, the rounding strategy should be reviewed
self.assertPresqueEqual(inv.total(), line['amount'])
self.assertEqual(inv.taskDate, line['paymentDate'])
self.assertEqual(inv.financial_year, line['paymentDate'].year)
for inv in invoices:
print inv.total()
total = sum([inv.total() for inv in invoices])
self.assertEqual(total, est.total())
def test_light_gen_invoice(dbsession, estimation):
from autonomie.models.task import Invoice
user = dbsession.query(User).first()
customer = dbsession.query(Customer).first()
project = dbsession.query(Project).first()
phase = dbsession.query(Phase).first()
estimation.phase = phase
estimation.project = project
estimation.owner = user
estimation.customer = customer
estimation.statusPersonAccount = user
invoices = estimation.gen_invoices(user)
for inv in invoices:
dbsession.add(inv)
dbsession.flush()
invoices = Invoice.query().filter(
Invoice.estimation_id==estimation.id
).all()
#deposit :
deposit = invoices[0]
assert deposit.taskDate == datetime.date.today()
assert deposit.financial_year == datetime.date.today().year
assert deposit.total() == estimation.deposit_amount_ttc()
#intermediate invoices:
intermediate_invoices = invoices[1:-1]
def test_gen_invoice(dbsession, estimation):
from autonomie.models.task import Invoice
user = dbsession.query(User).first()
customer = dbsession.query(Customer).first()
project = dbsession.query(Project).first()
phase = dbsession.query(Phase).first()
estimation.phase = phase
estimation.project = project
estimation.owner = user
estimation.customer = customer
estimation.statusPersonAccount = user
invoices = estimation.gen_invoices(user)
for inv in invoices:
dbsession.add(inv)
dbsession.flush()
invoices = Invoice.query().filter(
Invoice.estimation_id==estimation.id
).all()
#deposit :
deposit = invoices[0]
assert deposit.taskDate == datetime.date.today()
assert deposit.financial_year == datetime.date.today().year
assert deposit.total() == estimation.deposit_amount_ttc()
#intermediate invoices:
intermediate_invoices = invoices[1:-1]
for index, line in enumerate(PAYMENT_LINES[:-1]):
inv = intermediate_invoices[index]
# Here, the rounding strategy should be reviewed
assert inv.total() - line['amount'] <= 1
assert inv.taskDate == line['paymentDate']
assert inv.financial_year == line['paymentDate'].year
total = sum([inv.total() for inv in invoices])
assert total == estimation.total()
def upgrade():
logger = logging.getLogger("alembic.add_compte_cg")
op.add_column("tva", sa.Column("compte_cg", sa.String(125), default=""))
op.add_column("tva", sa.Column("code", sa.String(125), default=""))
op.add_column("company", sa.Column("contribution", sa.Integer))
op.add_column("customer", sa.Column("compte_cg",
sa.String(125),
default=""))
op.add_column("customer",
sa.Column("compte_tiers", sa.String(125), default=""))
# Ajout du code produit au ligne des factures et avoirs
for table in ("invoice_line", "cancelinvoice_line"):
op.add_column(table, sa.Column("product_id", sa.Integer, default=""))
# Ajout d'un tag "exporte" aux factures et avoirs
for table in ("invoice", "cancelinvoice"):
op.add_column(table, sa.Column("exported", sa.Boolean()))
# Les factures et avoirs deja validees sont considerees comme exportees
logger.warn(u"On tag des factures comme exportees")
for invoice in Invoice.query():
if invoice.CAEStatus in Invoice.valid_states:
invoice.exported = True
DBSESSION().merge(invoice)
logger.warn(u"officialNumber : {0.officialNumber} \
{0.financial_year}".format(invoice))
for cinv in CancelInvoice.query():
if cinv.CAEStatus in CancelInvoice.valid_states:
cinv.exported = True
DBSESSION().merge(cinv)
logger.warn(u"officialNumber : {0.officialNumber} \
{0.financial_year}".format(cinv))
def test_gen_invoice(dbsession, estimation):
from autonomie.models.task import Invoice
invoices = estimation.gen_invoices(user)
for inv in invoices:
dbsession.add(inv)
dbsession.flush()
invoices = Invoice.query().filter(
Invoice.estimation_id==estimation.id
).all()
#deposit :
deposit = invoices[0]
assert deposit.date == datetime.date.today()
assert deposit.financial_year == datetime.date.today().year
assert deposit.total() == estimation.deposit_amount_ttc()
assert deposit.mentions == estimation.mentions
#intermediate invoices:
intermediate_invoices = invoices[1:-1]
for index, line in enumerate(PAYMENT_LINES[:-1]):
inv = intermediate_invoices[index]
# Here, the rounding strategy should be reviewed
assert inv.total() - line['amount'] <= 1
assert inv.date == line['paymentDate']
assert inv.financial_year == line['paymentDate'].year
assert inv.mentions == estimation.mentions
total = sum([i.total() for i in invoices])
assert total == estimation.total()
def test_gen_invoice(dbsession, estimation):
from autonomie.models.task import Invoice
user = dbsession.query(User).first()
customer = dbsession.query(Customer).first()
project = dbsession.query(Project).first()
phase = dbsession.query(Phase).first()
estimation.phase = phase
estimation.project = project
estimation.owner = user
estimation.customer = customer
estimation.statusPersonAccount = user
invoices = estimation.gen_invoices(user)
for inv in invoices:
dbsession.add(inv)
dbsession.flush()
invoices = Invoice.query().filter(
Invoice.estimation_id == estimation.id).all()
#deposit :
deposit = invoices[0]
assert deposit.taskDate == datetime.date.today()
assert deposit.financial_year == datetime.date.today().year
assert deposit.total() == estimation.deposit_amount_ttc()
#intermediate invoices:
intermediate_invoices = invoices[1:-1]
for index, line in enumerate(PAYMENT_LINES[:-1]):
inv = intermediate_invoices[index]
# Here, the rounding strategy should be reviewed
assert inv.total() - line['amount'] <= 1
assert inv.taskDate == line['paymentDate']
assert inv.financial_year == line['paymentDate'].year
total = sum([inv.total() for inv in invoices])
assert total == estimation.total()
def turnovers(self):
"""
Return the realised turnovers
"""
result = dict(year_total=0)
for month in range(1, 13):
invoices = Invoice.query().join(Task.project)
invoices = invoices.filter(
Project.company_id == self.request.context.id)
date_condition = and_(
extract('year', Invoice.taskDate) == self.year,
extract('month', Invoice.taskDate) == month,
Invoice.financial_year == self.year,
)
if month != 12:
invoices = invoices.filter(date_condition)
else:
# for december, we also like to have invoices edited in january
# and reported to the previous comptability year
reported_condition = and_(
Invoice.financial_year == self.year,
extract('year', Invoice.taskDate) != self.year,
)
invoices = invoices.filter(
or_(date_condition, reported_condition))
invoices = invoices.filter(
Invoice.CAEStatus.in_(Invoice.valid_states))
invoice_sum = sum([invoice.total_ht() for invoice in invoices])
cinvoices = CancelInvoice.query().join(Task.project)
cinvoices = cinvoices.filter(
Project.company_id == self.request.context.id)
date_condition = and_(
extract('year', CancelInvoice.taskDate) == self.year,
extract('month', CancelInvoice.taskDate) == month,
CancelInvoice.financial_year == self.year,
)
if month != 12:
cinvoices = cinvoices.filter(date_condition)
else:
reported_condition = and_(
CancelInvoice.financial_year == self.year,
extract('year', CancelInvoice.taskDate) != self.year,
)
cinvoices = cinvoices.filter(
or_(date_condition, reported_condition))
cinvoices = cinvoices.filter(
CancelInvoice.CAEStatus.in_(CancelInvoice.valid_states))
cinvoice_sum = sum([cinvoice.total_ht() for cinvoice in cinvoices])
result[month] = invoice_sum + cinvoice_sum
result['year_total'] += result[month]
return result
def test_light_gen_invoice(dbsession, estimation):
from autonomie.models.task import Invoice
invoices = estimation.gen_invoices(estimation.owner)
for inv in invoices:
dbsession.add(inv)
dbsession.flush()
invoices = Invoice.query().filter(
Invoice.estimation_id==estimation.id
).all()
#deposit :
deposit = invoices[0]
assert deposit.date == datetime.date.today()
assert deposit.address == estimation.address
assert deposit.workplace == estimation.workplace
assert deposit.financial_year == datetime.date.today().year
assert deposit.total() == estimation.deposit_amount_ttc()
assert deposit.mentions == estimation.mentions
def turnovers(self):
"""
Return the realised turnovers
"""
result = dict(year_total=0)
for month in range(1, 13):
invoices = Invoice.query().join(Project)
invoices = invoices.filter(
Project.company_id==self.request.context.id
)
invoices = invoices.filter(
extract('year', Invoice.taskDate)==self.year
)
invoices = invoices.filter(
extract('month', Invoice.taskDate)==month
)
invoices = invoices.filter(
Invoice.CAEStatus.in_(Invoice.valid_states)
)
invoice_sum = sum([invoice.total_ht() for invoice in invoices])
cinvoices = CancelInvoice.query().join(Project)
cinvoices = cinvoices.filter(
Project.company_id==self.request.context.id
)
cinvoices = cinvoices.filter(
extract('year', CancelInvoice.taskDate)==self.year
)
cinvoices = cinvoices.filter(
extract('month', CancelInvoice.taskDate)==month
)
cinvoices = cinvoices.filter(
CancelInvoice.CAEStatus.in_(CancelInvoice.valid_states)
)
cinvoice_sum = sum([cinvoice.total_ht() for cinvoice in cinvoices])
result[month] = invoice_sum + cinvoice_sum
result['year_total'] += result[month]
return result
def test_light_gen_invoice(dbsession, estimation):
from autonomie.models.task import Invoice
user = dbsession.query(User).first()
customer = dbsession.query(Customer).first()
project = dbsession.query(Project).first()
phase = dbsession.query(Phase).first()
estimation.phase = phase
estimation.project = project
estimation.owner = user
estimation.customer = customer
estimation.statusPersonAccount = user
invoices = estimation.gen_invoices(user)
for inv in invoices:
dbsession.add(inv)
dbsession.flush()
invoices = Invoice.query().filter(
Invoice.estimation_id == estimation.id).all()
#deposit :
deposit = invoices[0]
assert deposit.taskDate == datetime.date.today()
assert deposit.financial_year == datetime.date.today().year
assert deposit.total() == estimation.deposit_amount_ttc()
#intermediate invoices:
intermediate_invoices = invoices[1:-1]
def turnovers(self):
"""
Return the realised turnovers
"""
result = dict(year_total=0)
for month in range(1, 13):
invoices = Invoice.query().join(Task.project)
invoices = invoices.filter(
Project.company_id==self.request.context.id
)
date_condition = and_(
extract('year', Invoice.taskDate)==self.year,
extract('month', Invoice.taskDate)==month,
Invoice.financial_year==self.year,
)
if month != 12:
invoices = invoices.filter(date_condition)
else:
# for december, we also like to have invoices edited in january
# and reported to the previous comptability year
reported_condition = and_(
Invoice.financial_year==self.year,
extract('year', Invoice.taskDate)!=self.year,
)
invoices = invoices.filter(
or_(date_condition, reported_condition)
)
invoices = invoices.filter(
Invoice.CAEStatus.in_(Invoice.valid_states)
)
invoice_sum = sum([invoice.total_ht() for invoice in invoices])
cinvoices = CancelInvoice.query().join(Task.project)
cinvoices = cinvoices.filter(
Project.company_id==self.request.context.id
)
date_condition = and_(
extract('year', CancelInvoice.taskDate)==self.year,
extract('month', CancelInvoice.taskDate)==month,
CancelInvoice.financial_year==self.year,
)
if month != 12:
cinvoices = cinvoices.filter(date_condition)
else:
reported_condition = and_(
CancelInvoice.financial_year==self.year,
extract('year', CancelInvoice.taskDate)!=self.year,
)
cinvoices = cinvoices.filter(
or_(date_condition, reported_condition)
)
cinvoices = cinvoices.filter(
CancelInvoice.CAEStatus.in_(CancelInvoice.valid_states)
)
cinvoice_sum = sum([cinvoice.total_ht() for cinvoice in cinvoices])
result[month] = invoice_sum + cinvoice_sum
result['year_total'] += result[month]
return result
