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["invoice"])
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 test_invoice(self):
self.setitUp()
inv = Invoice(**INVOICE)
inv.project = self.project
inv.phase = self.phase
self.session.add(inv)
self.session.flush()
task = self.session.query(Task)\
.filter(Task.phase_id==self.phase.id).first()
self.assertTrue(isinstance(task, Invoice))
def test_invoice(dbsession, objects):
user, phase, project = objects
inv = Invoice(**INVOICE)
inv.project = project
inv.phase = phase
dbsession.add(inv)
dbsession.flush()
task = dbsession.query(Task)\
.filter(Task.phase_id==phase.id).first()
assert isinstance(task, Invoice)
def test_invoice(dbsession, objects):
user, phase, project = objects
inv = Invoice(**INVOICE)
inv.project = project
inv.phase = phase
dbsession.add(inv)
dbsession.flush()
task = dbsession.query(Task)\
.filter(Task.phase_id==phase.id).first()
assert isinstance(task, Invoice)
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["invoice"])
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 test_payment(self):
self.setitUp()
inv = Invoice(**INVOICE)
inv.CAEStatus = "valid"
#inv.project = self.project
inv.phase = self.phase
inv.record_payment(amount=1500, mode="CHEQUE", resulted=True)
self.session.add(inv)
self.session.flush()
p1 = self.session.query(Payment).join(Task)\
.filter(Task.phase_id==self.phase.id).first()
self.assertTrue(isinstance(p1.task, Invoice))
self.assertFalse(isinstance(p1.task, CancelInvoice))
def test_payment(dbsession, objects):
user, phase, project = objects
inv = Invoice(**INVOICE)
inv.CAEStatus = "valid"
#inv.project = project
inv.phase = phase
inv.record_payment(amount=1500, mode="CHEQUE", resulted=True)
dbsession.add(inv)
dbsession.flush()
p1 = dbsession.query(Payment).join(Task)\
.filter(Task.phase_id==phase.id).first()
assert isinstance(p1.task, Invoice)
assert not isinstance(p1.task, CancelInvoice)
def invoice(config, get_csrf_request_with_db, project, user):
print(Invoice.query().all())
assert len(Invoice.query().all()) == 0
from autonomie.views.invoice import InvoiceAdd
config.add_route('project', '/')
request = get_csrf_request_with_db(post=APPSTRUCT)
request.context = project
request.context.__name__ = 'project'
request.matched_route = "project_invoices"
request.user = user
request.context = project
view = InvoiceAdd(request)
view.submit_success(APPSTRUCT)
return getone()
def invoice(config, get_csrf_request_with_db, project, user):
print(Invoice.query().all())
assert len(Invoice.query().all()) == 0
from autonomie.views.invoice import InvoiceAdd
config.add_route('project', '/')
request = get_csrf_request_with_db(post=APPSTRUCT)
request.context = project
request.context.__name__ = 'project'
request.matched_route = "project_invoices"
request.user = user
request.context = project
view = InvoiceAdd(request)
view.submit_success(APPSTRUCT)
return getone()
def test_add_invoice(config, get_csrf_request_with_db, project, phase, company,
user, customer, ):
from autonomie.models.task.invoice import Invoice
from autonomie.views.invoices.invoice import InvoiceAddView
config.add_route('/invoices/{id}', "/")
value = {
"name": u"Facture",
'course': True,
'project_id': project.id,
'phase_id': phase.id,
'customer_id': customer.id,
}
request = get_csrf_request_with_db()
request.context = project
request.current_company = company.id
request.matched_route = Dummy(name="project_invoices")
request.user = user
view = InvoiceAddView(request)
view.submit_success(value)
# view.submit_success(value)
invoice = Invoice.query().first()
assert invoice.name == u"Facture"
assert invoice.phase_id == phase.id
assert invoice.customer_id == customer.id
assert invoice.project_id == project.id
assert invoice.course is True
def getOne(self):
try:
invoice = Invoice.query().filter(Invoice.phase_id==1).first()
invoice.__name__ = 'invoice'
return invoice
except:
return None
def _get_common_invoice(cls, estimation, user):
"""
Prepare a new Invoice related to the given estimation
:param obj estimation: The estimation we're starting from
:param obj user: The user generating the new document
:returns: A new Invoice
:rtype: `class:Invoice`
"""
from autonomie.models.task.invoice import Invoice
invoice = Invoice(
user=user,
company=estimation.company,
customer=estimation.customer,
project=estimation.project,
phase_id=estimation.phase_id,
estimation=estimation,
payment_conditions=estimation.payment_conditions,
description=estimation.description,
address=estimation.address,
workplace=estimation.workplace,
mentions=estimation.mentions,
business_type_id=estimation.business_type_id,
)
return invoice
def test_add_invoice(
config, get_csrf_request_with_db, project, phase, company,
user, customer, default_business_type,
):
from autonomie.models.task.invoice import Invoice
from autonomie.views.project.routes import PROJECT_ITEM_INVOICE_ROUTE
from autonomie.views.invoices.invoice import InvoiceAddView
config.add_route('/invoices/{id}', "/")
value = {
"name": u"Facture",
'business_type_id': default_business_type.id,
'project_id': project.id,
'phase_id': phase.id,
'customer_id': customer.id,
}
request = get_csrf_request_with_db()
request.context = project
request.current_company = company.id
request.matched_route = Dummy(name=PROJECT_ITEM_INVOICE_ROUTE)
request.user = user
view = InvoiceAddView(request)
view.submit_success(value)
# view.submit_success(value)
invoice = Invoice.query().first()
assert invoice.name == u"Facture"
assert invoice.phase_id == phase.id
assert invoice.customer_id == customer.id
assert invoice.project_id == project.id
assert invoice.business_type_id == default_business_type.id
def upgrade():
# Devis
op.add_column("estimation_line",
sa.Column("tva", sa.Integer))
# Adding tva to the lines
op.execute("""
update estimation_line as l join estimation as e on e.id=l.task_id set l.tva=e.tva;
""")
# Moving dicounts to a discount table
for est in Estimation.query().all():
id_ = est.id
op.execute("""
insert discount (description, amount, tva, task_id) select "Remise", discountHT, tva, id from estimation where estimation.id='%s' and estimation.discountHT!= 0 and estimation.discountHT is not null ;
"""% (id_))
# Factures
op.add_column("invoice_line",
sa.Column("tva", sa.Integer))
# Adding tva to the lines
op.execute("""
update invoice_line as l join invoice as i on i.id=l.task_id set l.tva=i.tva;
""")
# Moving discounts to discount table
for inv in Invoice.query().all():
id_ = inv.id
op.execute("""
insert discount (description, amount, tva, task_id) select "Remise", discountHT, tva, id from invoice where invoice.id='%s' and invoice.discountHT!= 0 and invoice.discountHT is not null ;
"""% (id_))
# Avoirs
add_column("cancelinvoice_line",
sa.Column("tva", sa.Integer))
if column_exists("cancelinvoice", "tva"):
# If the column exists, there may be some cancelinvoices
op.execute("""
update cancelinvoice_line as l join cancelinvoice as i on i.id=l.task_id set l.tva=i.tva;
""")
def invoice(project, user, customer, company):
invoice = Invoice(
company,
customer,
project,
project.phases[-1],
user,
)
for key, value in INVOICE.items():
setattr(invoice, key, value)
return invoice
def add_invoice(cls, business, user):
"""
Freely add a new invoice to the current business
:param obj business: The current business instance this service is
attached to
:returns: A new Invoice instance
"""
from autonomie.models.task.invoice import Invoice
invoice = Invoice(
user=user,
company=business.project.company,
project=business.project,
customer_id=cls._get_customer_id(business),
business_id=business.id,
business_type_id=business.business_type_id,
)
invoice.initialize_business_datas()
DBSESSION().add(invoice)
DBSESSION().flush()
return invoice
def test_duplicate(self):
self.config.testing_securitypolicy(userid="test",
groupids=('admin',), permissive=True)
self.config.add_route('invoice', '/inv')
self.addOne()
invoice = self.getOne()
#The invoice status need to be at least wait to be duplicated
invoice.CAEStatus = 'wait'
request = self.request(task=invoice, post_args={'submit':'duplicate',
'phase':"1", 'project':"1", 'customer':"1"})
duplicate(request)
invoices = Invoice.query().filter(Invoice.phase_id==1).all()
self.assertEqual(len(invoices), 2)
def _mk_invoice(date=None, company=company):
from autonomie.models.task.invoice import Invoice
invoice = Invoice(
company=company,
project=project,
customer=customer,
phase=phase,
user=user,
date=date,
)
dbsession.add(invoice)
dbsession.flush()
return invoice
def deferred_invoice_widget(node, kw):
"""
Return a select for estimation selection
"""
query = Invoice.query()
query = query.filter_by(project_id=kw['request'].context.project_id)
choices = []
for invoice in query:
if invoice.estimation_id is None:
label = invoice.name
else:
label = u"{0} (est déjà rattachée à un devis)".format(invoice.name)
choices.append((invoice.id, label))
return deform.widget.CheckboxChoiceWidget(values=choices)
def deferred_invoice_widget(node, kw):
"""
Return a select for estimation selection
"""
query = Invoice.query()
query = query.filter_by(project_id=kw['request'].context.project_id)
choices = []
for invoice in query:
if invoice.estimation_id is None:
label = invoice.name
else:
label = u"{0} (est déjà rattachée à un devis)".format(invoice.name)
choices.append((invoice.id, label))
return deform.widget.CheckboxChoiceWidget(values=choices)
def test_duplicate(config, content, dbsession, invoice, get_csrf_request_with_db):
from autonomie.views.invoice import duplicate
config.testing_securitypolicy(userid="test", groupids=('admin',),
permissive=True)
config.add_route('invoice', '/inv')
#The invoice status need to be at least wait to be duplicated
invoice.CAEStatus = 'wait'
request = get_csrf_request_with_db(
post={'submit':'duplicate', 'phase':"1", 'project':"1", 'customer':"1"}
)
request.context = invoice
request.matched_route = "invoice"
duplicate(request)
dbsession.flush()
invoices = Invoice.query().filter(Invoice.phase_id==1).all()
assert len(invoices) == 2
def test_payment(dbsession, objects):
user, phase, project = objects
inv = Invoice(**INVOICE)
inv.CAEStatus = "valid"
#inv.project = project
inv.phase = phase
inv.record_payment(amount=1500, mode="CHEQUE", resulted=True)
dbsession.add(inv)
dbsession.flush()
p1 = dbsession.query(Payment).join(Task)\
.filter(Task.phase_id==phase.id).first()
assert isinstance(p1.task, Invoice)
assert not isinstance(p1.task, CancelInvoice)
def test_duplicate(config, content, dbsession, invoice,
get_csrf_request_with_db):
from autonomie.views.invoice import duplicate
config.testing_securitypolicy(userid="test",
groupids=('admin', ),
permissive=True)
config.add_route('invoice', '/inv')
#The invoice status need to be at least wait to be duplicated
invoice.CAEStatus = 'wait'
request = get_csrf_request_with_db(post={
'submit': 'duplicate',
'phase': "1",
'project': "1",
'customer': "1"
})
request.context = invoice
request.matched_route = "invoice"
duplicate(request)
dbsession.flush()
invoices = Invoice.query().filter(Invoice.phase_id == 1).all()
assert len(invoices) == 2
def invoice(
dbsession,
tva,
unity,
project,
customer,
company,
user,
phase,
):
from autonomie.models.task.invoice import Invoice
invoice = Invoice(
company=company,
project=project,
customer=customer,
user=user,
phase=phase,
)
dbsession.add(invoice)
dbsession.flush()
return invoice
def getone():
invoice = Invoice.query().filter(Invoice.phase_id == 1).first()
if invoice is not None:
invoice.__name__ = 'invoice'
return invoice
def getone():
invoice = Invoice.query().filter(Invoice.phase_id==1).first()
if invoice is not None:
invoice.__name__ = 'invoice'
return invoice
