def project2(dbsession, company2, customer2, project_type):
from autonomie.models.project import Project
project = Project(name=u"Project 2", project_type=project_type)
project.company = company2
project.customers = [customer2]
dbsession.add(project)
dbsession.flush()
return project
def project(dbsession, company, customer, project_type):
from autonomie.models.project import Project
project = Project(name=u"Project", project_type=project_type)
project.company = company
project.customers = [customer]
dbsession.add(project)
dbsession.flush()
return project
def project2(dbsession, company2, customer2):
from autonomie.models.project import Project
project = Project(name=u"Project 2")
project.company = company2
project.customers = [customer2]
dbsession.add(project)
dbsession.flush()
return project
def add_project(customer, company, project_name, project_code):
project = Project(name=project_name, code=project_code)
project.customers.append(customer)
project.company = company
session = DBSESSION()
session.add(project)
session.flush()
print u"Added project to %s for %s: %s" % (company.name, customer.name,
project_name)
return project
def func(
name=u'Project', company=company, customers=[customer],
project_type=project_type
):
if not hasattr(customers, '__iter__'):
customers = [customers]
project = Project(name=u"Project", project_type=project_type)
project.company = company
project.customers = customers
dbsession.add(project)
dbsession.flush()
return project
def func(name=u'Project',
company=company,
customers=[customer],
project_type=project_type):
if not hasattr(customers, '__iter__'):
customers = [customers]
project = Project(name=u"Project", project_type=project_type)
project.company = company
project.customers = customers
dbsession.add(project)
dbsession.flush()
return project
def submit_success(self, appstruct):
if self.factory is None:
raise Exception("Forgot to set the factory attribute")
name = appstruct['name']
phase_id = appstruct['phase_id']
phase = Phase.get(phase_id)
project_id = appstruct['project_id']
project = Project.get(project_id)
customer_id = appstruct['customer_id']
customer = Customer.get(customer_id)
new_object = self.factory(
self.context.company,
customer,
project,
phase,
self.request.user,
)
new_object.name = name
if hasattr(self, "_more_init_attributes"):
self._more_init_attributes(new_object, appstruct)
self.dbsession.add(new_object)
self.dbsession.flush()
if hasattr(self, "_after_flush"):
self._after_flush(new_object)
url = self.request.route_path("/%ss/{id}" % new_object.type_,
id=new_object.id)
return HTTPFound(url)
def submit_success(self, appstruct):
logger.debug("# Duplicating a document #")
name = appstruct['name']
phase_id = appstruct['phase_id']
phase = Phase.get(phase_id)
project_id = appstruct['project_id']
project = Project.get(project_id)
customer_id = appstruct['customer_id']
customer = Customer.get(customer_id)
task = self.context.duplicate(
self.request.user,
project,
phase,
customer,
)
task.name = name
task.course = appstruct['course']
self.dbsession.add(task)
self.dbsession.flush()
logger.debug(
u"The {t.type_} {t.id} has been duplicated to {new_t.id}".format(
t=self.context, new_t=task))
return HTTPFound(
self.request.route_path('/%ss/{id}' % self.context.type_,
id=task.id))
def submit_success(self, appstruct):
if self.factory is None:
raise Exception("Forgot to set the factory attribute")
project_id = appstruct.pop('project_id')
appstruct['project'] = Project.get(project_id)
customer_id = appstruct.pop('customer_id')
appstruct['customer'] = Customer.get(customer_id)
new_object = self.factory(
user=self.request.user,
company=self.context.company,
**appstruct
)
if hasattr(self, "_more_init_attributes"):
self._more_init_attributes(new_object, appstruct)
self.dbsession.add(new_object)
self.dbsession.flush()
if hasattr(self, "_after_flush"):
self._after_flush(new_object)
url = self.request.route_path(
"/%ss/{id}" % new_object.type_,
id=new_object.id
)
return HTTPFound(url)
def submit_success(self, appstruct):
logger.debug("# Duplicating a document #")
project_id = appstruct.pop('project_id')
appstruct['project'] = Project.get(project_id)
customer_id = appstruct.pop('customer_id')
appstruct['customer'] = Customer.get(customer_id)
task = self.context.duplicate(
user=self.request.user,
**appstruct
)
if hasattr(self, "_after_task_duplicate"):
self._after_task_duplicate(task, appstruct)
self.dbsession.add(task)
self.dbsession.flush()
logger.debug(
u"The {t.type_} {t.id} has been duplicated to {new_t.id}".format(
t=self.context,
new_t=task
)
)
return HTTPFound(
self.request.route_path(
'/%ss/{id}' % self.context.type_,
id=task.id
)
)
def query(self):
company = self.request.context
# We can't have projects without having customers
if not company.customers:
redirect_to_customerslist(self.request, company)
return Project.query().outerjoin(Project.customers).filter(
Project.company_id == company.id)
def get_all_projects(request):
query = Project.label_query()
customer_ids = [c.id for c in get_customers_from_request(request)]
projects = query.filter(
Project.customers.any(Customer.id.in_(customer_ids)))
return projects.all()
def submit_success(self, appstruct):
if self.factory is None:
raise Exception("Forgot to set the factory attribute")
project_id = appstruct.pop('project_id')
appstruct['project'] = Project.get(project_id)
customer_id = appstruct.pop('customer_id')
appstruct['customer'] = Customer.get(customer_id)
new_object = self.factory(
user=self.request.user,
company=self.context.company,
**appstruct
)
if hasattr(self, "_more_init_attributes"):
self._more_init_attributes(new_object, appstruct)
self.dbsession.add(new_object)
self.dbsession.flush()
if hasattr(self, "_after_flush"):
self._after_flush(new_object)
url = self.request.route_path(
"/%ss/{id}" % new_object.type_,
id=new_object.id
)
return HTTPFound(url)
def get_projects_from_request(request):
"""
Return the projects regarding the current request
"""
company_id = request.current_company
projects = Project.query().filter_by(company_id=company_id).all()
return projects
def objects():
user = User(login=u"test_user1",
firstname=u"firstname",
lastname=u"lastname")
project = Project(name=u"Projet", code=u"PROJ")
phase = Phase(name="test", project=project)
return (user, phase, project)
def submit_success(self, appstruct):
logger.debug("# Duplicating a document #")
project_id = appstruct.pop('project_id')
appstruct['project'] = Project.get(project_id)
customer_id = appstruct.pop('customer_id')
appstruct['customer'] = Customer.get(customer_id)
task = self.context.duplicate(
user=self.request.user,
**appstruct
)
if hasattr(self, "_after_task_duplicate"):
self._after_task_duplicate(task, appstruct)
self.dbsession.add(task)
self.dbsession.flush()
logger.debug(
u"The {t.type_} {t.id} has been duplicated to {new_t.id}".format(
t=self.context,
new_t=task
)
)
return HTTPFound(
self.request.route_path(
'/%ss/{id}' % self.context.type_,
id=task.id
)
)
def get_all_projects(request):
query = Project.label_query()
customer_ids = [c.id for c in get_customers_from_request(request)]
projects = query.filter(
Project.customers.any(Customer.id.in_(customer_ids))
)
return projects.all()
def test_gen_cancelinvoice_payment(dbsession, invoice):
user = User.query().first()
project = Project.query().first()
invoice.project = project
invoice.owner = user
invoice.statusPersonAccount = user
invoice.record_payment(mode="c", amount=1500)
cinv = invoice.gen_cancelinvoice(user)
assert len(cinv.lines) == len(invoice.lines) + len(invoice.discounts) + 1
assert cinv.lines[-1].cost == 1500
def test_gen_cancelinvoice_payment(dbsession, invoice):
user = User.query().first()
project = Project.query().first()
invoice.project = project
invoice.owner = user
invoice.statusPersonAccount = user
invoice.record_payment(mode="c", amount=1500)
cinv = invoice.gen_cancelinvoice(user)
assert len(cinv.lines) == len(invoice.lines) + len(invoice.discounts) + 1
assert cinv.lines[-1].cost == 1500
def test_gen_cancelinvoice_payment(self):
user = User.query().first()
project = Project.query().first()
inv = self.getOne()
inv.project = project
inv.owner = user
inv.statusPersonAccount = user
inv.record_payment(mode="c", amount=1500)
cinv = inv.gen_cancelinvoice(user)
self.assertEqual(len(cinv.lines),
len(inv.lines) + len(inv.discounts) + 1)
self.assertEqual(cinv.lines[-1].cost, 1500)
def submit_success(self, appstruct):
"""
Add a project with a default phase in the database
"""
project = Project()
project.company_id = self.request.context.id
customer_ids = appstruct.pop("customers", [])
project = merge_session_with_post(project, appstruct)
for customer_id in customer_ids:
customer = Customer.get(customer_id)
if customer:
project.customers.append(customer)
self.dbsession.add(project)
self.dbsession.flush()
# Add a default phase to the project
default_phase = Phase()
default_phase.project = project
self.dbsession.add(default_phase)
message = u"Le projet <b>{0}</b> a été ajouté avec succès".format(
project.name)
self.request.session.flash(message)
return HTTPFound(self.request.route_path('project', id=project.id))
def populate_db(session):
from autonomie.models.user import User
user = User(
login='******',
firstname='user1_firstname',
lastname="user1_lastname",
email="*****@*****.**"
)
user.set_password('o')
session.add(user)
from autonomie.models.project import Project
project = Project(
name='Projet 1',
code='P001',
definition="Projet 1"
)
session.add(project)
from autonomie.models.customer import Customer
cust = Customer(
code='C001',
name='Client1',
contactLastName=u'Client Lastname',
address=u'15 rue Victore Hugo',
zipCode='69003',
city='Lyon',
)
cust.projects.append(project)
session.add(cust)
from autonomie.models.project import Phase
phase = Phase(name='Phase de test')
phase.project = project
session.add(phase)
from autonomie.models.company import Company
c = Company(
name="company1",
goal="Company of user1",
phone='0457858585',
)
c.employees.append(user)
c.customers.append(cust)
c.projects.append(project)
session.add(c)
from autonomie.scripts import fake_database
fake_database.set_configuration()
def test_gen_cancelinvoice(dbsession, invoice):
user = User.query().first()
project = Project.query().first()
invoice.project = project
invoice.owner = user
invoice.statusPersonAccount = user
dbsession.add(invoice)
dbsession.flush()
cinv = invoice.gen_cancelinvoice(user)
dbsession.add(cinv)
dbsession.flush()
assert cinv.name == "Avoir 1"
assert cinv.total_ht() == -1 * invoice.total_ht()
today = datetime.date.today()
assert cinv.taskDate == today
def test_gen_cancelinvoice(dbsession, invoice):
user = User.query().first()
project = Project.query().first()
invoice.project = project
invoice.owner = user
invoice.statusPersonAccount = user
dbsession.add(invoice)
dbsession.flush()
cinv = invoice.gen_cancelinvoice(user)
dbsession.add(cinv)
dbsession.flush()
assert cinv.name == "Avoir 1"
assert cinv.total_ht() == -1 * invoice.total_ht()
today = datetime.date.today()
assert cinv.taskDate == today
def deferred_project_widget(node, kw):
"""
return phase select widget
"""
if isinstance(kw['request'].context, Project):
wid = deform.widget.HiddenWidget()
else:
customer_id = deferred_default_customer(node, kw)
if customer_id != 0:
projects = Project.get_customer_projects(customer_id)
else:
projects = []
choices = _get_project_choices(projects)
wid = deform.widget.SelectWidget(values=choices)
return wid
def deferred_project_widget(node, kw):
"""
return phase select widget
"""
if isinstance(kw['request'].context, Project):
wid = deform.widget.HiddenWidget()
else:
customer_id = deferred_default_customer(node, kw)
if customer_id != 0:
projects = Project.get_customer_projects(customer_id)
else:
projects = []
choices = _get_project_choices(projects)
wid = deform.widget.SelectWidget(values=choices)
return wid
def test_gen_cancelinvoice(self):
user = User.query().first()
project = Project.query().first()
inv = self.getOne()
inv.project = project
inv.owner = user
inv.statusPersonAccount = user
self.session.add(inv)
self.session.flush()
cinv = inv.gen_cancelinvoice(user)
self.session.add(cinv)
self.session.flush()
self.assertEqual(cinv.name, "Avoir 1")
self.assertEqual(cinv.total_ht(), -1 * inv.total_ht())
today = datetime.date.today()
self.assertEqual(cinv.taskDate, today)
def validate_customer_project_phase(form, value):
"""
Validate that customer project and phase are linked
:param obj form: The form object
:param dict value: The submitted values
"""
customer_id = value['customer_id']
project_id = value['project_id']
phase_id = value.get('phase_id')
if phase_id and not Project.check_phase_id(project_id, phase_id):
exc = colander.Invalid(form, u"Projet et dossier ne correspondent pas")
exc['phase_id'] = u"Ne correspond pas au projet ci-dessus"
raise exc
if not Customer.check_project_id(customer_id, project_id):
exc = colander.Invalid(form, u"Client et projet ne correspondent pas")
exc['project_id'] = u"Ne correspond pas au client ci-dessus"
raise exc
def validate_customer_project_phase(form, value):
"""
Validate that customer project and phase are linked
:param obj form: The form object
:param dict value: The submitted values
"""
customer_id = value['customer_id']
project_id = value['project_id']
phase_id = value.get('phase_id')
if phase_id and not Project.check_phase_id(project_id, phase_id):
exc = colander.Invalid(form, u"Projet et dossier ne correspondent pas")
exc['phase_id'] = u"Ne correspond pas au projet ci-dessus"
raise exc
if not Customer.check_project_id(customer_id, project_id):
exc = colander.Invalid(form, u"Client et projet ne correspondent pas")
exc['project_id'] = u"Ne correspond pas au client ci-dessus"
raise exc
def pre_duplicate_process(self, task, status, params):
"""
Common pre process method for document duplication
"""
form = get_duplicate_form(self.request)
# if an error is raised here, it will be cached a level higher
appstruct = form.validate(params.items())
log.debug(u" * Form has been validated")
customer_id = appstruct.get('customer')
customer = Customer.get(customer_id)
project_id = appstruct.get('project')
project = Project.get(project_id)
phase_id = appstruct.get('phase')
phase = Phase.get(phase_id)
log.debug(u" * Phase : %s" % phase)
log.debug(u" * Project : %s" % project)
appstruct['phase'] = phase
appstruct['project'] = project
appstruct['customer'] = customer
appstruct['user'] = self.request.user
return appstruct
def pre_duplicate_process(self, task, status, params):
"""
Common pre process method for document duplication
"""
form = get_duplicate_form(self.request)
# if an error is raised here, it will be cached a level higher
appstruct = form.validate(params.items())
logger.debug(u" * Form has been validated")
customer_id = appstruct.get('customer')
customer = Customer.get(customer_id)
project_id = appstruct.get('project')
project = Project.get(project_id)
phase_id = appstruct.get('phase')
phase = Phase.get(phase_id)
logger.debug(u" * Phase : %s" % phase)
logger.debug(u" * Project : %s" % project)
appstruct['phase'] = phase
appstruct['project'] = project
appstruct['customer'] = customer
appstruct['user'] = self.request.user
return appstruct
def test_get_number():
test_str = "Devis 5"
assert Project.get_number(test_str, "Devis ") == 5
assert Project.get_number(test_str, "Devistoto") == 0
def getone():
from autonomie.models.project import Project
return Project.query().first()
def project_codes(self):
return Project.get_code_list_with_labels(self.context.company_id)
def project(content):
proj = Project.query().first()
proj.code = "PRO1"
proj.phases.append(Phase(name="test"))
return proj
def getone():
val = Project.query().filter(Project.name == "Projéct&$").first()
if val is not None:
val.__name__ = 'project'
return val
def project(content):
proj = Project.query().first()
proj.code = "PRO1"
return proj
def project(self):
return Project.query().first()
def getone():
from autonomie.models.project import Project
return Project.query().first()
def test_get_number():
test_str = "Devis 5"
assert Project.get_number(test_str, "Devis ") == 5
assert Project.get_number(test_str, "Devistoto") == 0
def project(content):
proj = Project.query().first()
proj.code = "PRO1"
return proj
def get_project_options(request):
customer_id = get_current_customer_id_from_request(request)
projects = Project.label_query().filter_by(customer_id=customer_id)
return [(pro.id, u"%s (%s)" % (pro.name, pro.code)) for pro in projects]
def test_check_phase_id(project, phase):
from autonomie.models.project import Project
assert Project.check_phase_id(project.id, phase.id)
def get_number(self):
test_str = "Devis 5"
self.assertEqual(Project.get_number(test_str, "Devis "), 5)
self.assertEqual(Project.get_number(test_str, "Devistoto"), 0)
def get_project_options(request):
customer_id = get_current_customer_id_from_request(request)
projects = Project.label_query().filter_by(customer_id=customer_id)
return [
(pro.id, u"%s (%s)" % (pro.name, pro.code)) for pro in projects
]
def project(content):
return Project.query().first()
def test_customer_projects(project, customer):
from autonomie.models.project import Project
assert Project.get_customer_projects(customer.id) == [project]
def getone():
val = Project.query().filter(Project.name=="Projéct&$").first()
if val is not None:
val.__name__ = 'project'
return val
def project_codes(self):
return Project.get_code_list_with_labels(self.context.company_id)
def getOne(self):
try:
return Project.query().filter(Project.name=="Projéct&$").one()
except:
return None
def project(content):
return Project.query().first()
def project(content):
proj = Project.query().first()
proj.code = "PRO1"
proj.phases.append(Phase(name="test"))
return proj
