def test_interfaces(self):
self.assertTrue(verifyObject(ITask, Task()))
self.assertTrue(verifyObject(IValidatedTask, Estimation()))
self.assertTrue(verifyObject(IPaidTask, Invoice()))
self.assertTrue(verifyObject(IPaidTask, CancelInvoice()))
self.assertTrue(verifyObject(IInvoice, Invoice()))
self.assertTrue(verifyObject(IInvoice, CancelInvoice()))
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 submit_success(self, appstruct):
log.debug("Submitting invoice add")
appstruct = get_invoice_dbdatas(appstruct)
# Since the call to get_next_invoice_number commits the current
# transaction, it needs to be called before creating our invoice, to
# avoid missing arguments errors
snumber = self.context.get_next_invoice_number()
invoice = Invoice()
invoice.project = self.context
invoice.owner = self.request.user
invoice = merge_session_with_post(
invoice,
appstruct["task"]
)
invoice.set_sequence_number(snumber)
invoice.set_number()
invoice.set_name()
try:
invoice = self.set_task_status(invoice)
# Line handling
invoice = add_lines_to_invoice(invoice, appstruct)
self.dbsession.add(invoice)
self.dbsession.flush()
self.session.flash(u"La facture a bien été ajoutée.")
except Forbidden, err:
self.request.session.flash(err.message, queue='error')
def invoice(project, user, customer, company, phase):
invoice = Invoice(
company,
customer,
project,
phase,
user,
)
invoice.line_groups = [TaskLineGroup(lines=[TaskLine(**LINE)])]
for i in PAYMENTS:
invoice.payments.append(Payment(**i))
return invoice
def invoice(project, user, customer, company, phase):
invoice = Invoice(
company,
customer,
project,
phase,
user,
)
invoice.line_groups = [TaskLineGroup(lines=[TaskLine(**LINE)])]
for i in PAYMENTS:
invoice.payments.append(Payment(**i))
return invoice
def test_set_name(self):
invoice = Invoice()
invoice.set_sequenceNumber(5)
invoice.set_name()
self.assertEqual(invoice.name, u"Facture 5")
invoice.set_name(sold=True)
self.assertEqual(invoice.name, u"Facture de solde")
invoice.set_name(deposit=True)
self.assertEqual(invoice.name, u"Facture d'acompte 5")
def invoice(project, user, customer, company, phase):
invoice = Invoice(company, customer, project, phase, user)
for key, value in INVOICE.items():
setattr(invoice, key, value)
for line in LINES:
invoice.default_line_group.lines.append(TaskLine(**line))
for discount in DISCOUNTS:
invoice.discounts.append(DiscountLine(**discount))
invoice.mentions = [TaskMention(label="1", title="t1", full_text="text")]
invoice.address = customer.address
return invoice
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 invoice():
inv = Invoice(**INVOICE)
for line in LINES:
inv.lines.append(InvoiceLine(**line))
for discount in DISCOUNTS:
inv.discounts.append(DiscountLine(**discount))
return inv
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 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 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
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 submit_success(self, appstruct):
log.debug("Submitting invoice add")
appstruct = get_invoice_dbdatas(appstruct)
customer_id = appstruct["task"]['customer_id']
customer = Customer.get(customer_id)
invoice = Invoice(
self.context.company,
customer,
self.context,
self.context.phases[0],
self.request.user,
)
invoice = merge_session_with_post(
invoice,
appstruct["task"]
)
try:
invoice = self.set_task_status(invoice)
# Line handling
invoice = add_lines_to_invoice(invoice, appstruct)
self.dbsession.add(invoice)
self.dbsession.flush()
self.session.flash(u"La facture a bien été ajoutée.")
except Forbidden, err:
self.request.session.flash(err.message, queue='error')
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_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
def submit_success(self, appstruct):
invoice_ids = appstruct.get('invoice_ids')
for invoice_id in invoice_ids:
invoice = Invoice.get(invoice_id)
invoice.estimation_id = self.context.id
self.request.dbsession.merge(invoice)
self.context.geninv = True
self.request.dbsession.merge(self.context)
return self.redirect()
def invoice(project, user, customer, company, phase):
task = Invoice(
company,
customer,
project,
phase,
user,
)
for key, value in TASK.items():
setattr(task, key, value)
return task
def invoice(project, user, customer, company, phase):
invoice = Invoice(
company,
customer,
project,
phase,
user,
)
for key, value in INVOICE.items():
setattr(invoice, key, value)
for line in LINES:
invoice.default_line_group.lines.append(TaskLine(**line))
for discount in DISCOUNTS:
invoice.discounts.append(DiscountLine(**discount))
invoice.mentions = [TaskMention(label='1', title='t1', full_text='text')]
invoice.address = customer.address
return invoice
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 func(req_type='mandatory', validation=False, add_req=True, **kwargs):
if add_req:
mk_business_type_file_types(
ftypes['ftype1'],
btypes['default'],
'invoice',
req_type,
validation
)
if 'project' not in kwargs:
kwargs['project'] = project
node = Invoice(
user=user,
company=company,
business_type_id=btypes['default'].id,
**kwargs
)
dbsession.add(node)
dbsession.flush()
SaleFileRequirementService.populate(node)
return node
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 invoice():
inv = Invoice(**INVOICE)
inv.line_groups = [TaskLineGroup(lines=[TaskLine(**LINE)])]
for i in PAYMENTS:
inv.payments.append(Payment(**i))
return inv
def test_set_number(self):
invoice = Invoice()
invoice.customer = MagicMock(code="CLI1")
invoice.project = MagicMock(code="PRO1")
seq_number = 15
invoice.set_sequenceNumber(15)
invoice.set_name()
date = datetime.date(1969, 07, 31)
invoice.taskDate = date
invoice.set_number()
self.assertEqual(invoice.number, u"PRO1_CLI1_F15_0769")
invoice.set_number(deposit=True)
self.assertEqual(invoice.number, u"PRO1_CLI1_FA15_0769")
def invoice():
inv = Invoice(**INVOICE)
inv.lines = [InvoiceLine(**LINE)]
for i in PAYMENTS:
inv.payments.append(Payment(**i))
return inv
def invoice():
inv = Invoice(**INVOICE)
inv.lines = [InvoiceLine(**LINE)]
for i in PAYMENTS:
inv.payments.append(Payment(**i))
return inv
def test_set_name():
invoice = Invoice()
invoice.set_sequence_number(5)
invoice.set_name()
assert invoice.name == u"Facture 5"
invoice.name = ""
invoice.set_name(sold=True)
assert invoice.name == u"Facture de solde"
invoice.name = ""
invoice.set_name(deposit=True)
assert invoice.name == u"Facture d'acompte 5"
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_set_number():
invoice = Invoice()
invoice.customer = MagicMock(code="CLI1")
invoice.project = MagicMock(code="PRO1")
seq_number = 15
invoice.set_sequence_number(15)
invoice.set_name()
date = datetime.date(1969, 07, 31)
invoice.taskDate = date
invoice.set_number()
assert invoice.number == u"PRO1_CLI1_F15_0769"
invoice.set_number(deposit=True)
assert invoice.number == u"PRO1_CLI1_FA15_0769"
def test_set_name():
invoice = Invoice()
invoice.set_sequence_number(5)
invoice.set_name()
assert invoice.name == u"Facture 5"
invoice.name = ""
invoice.set_name(sold=True)
assert invoice.name == u"Facture de solde"
invoice.name = ""
invoice.set_name(deposit=True)
assert invoice.name == u"Facture d'acompte 5"
