def submit_success(self, appstruct):
model = Phase()
model.project_id = self.context.id
merge_session_with_post(model, appstruct)
self.dbsession.add(model)
redirect = self.request.route_path("project", id=model.project_id)
return HTTPFound(redirect)
def phase2(dbsession, project2):
from autonomie.models.project import Phase
phase = Phase(name=u"Phase")
phase.project = project2
phase.project_id = project2.id
project2.phases.append(phase)
dbsession.add(phase)
dbsession.flush()
return phase
def phase(dbsession, project):
from autonomie.models.project import Phase
phase = Phase(name=u"Phase")
phase.project = project
phase.project_id = project.id
project.phases.append(phase)
dbsession.add(phase)
dbsession.flush()
return phase
def submit_success(self, appstruct):
model = Phase()
model.project_id = self.context.id
merge_session_with_post(model, appstruct)
self.dbsession.add(model)
self.dbsession.flush()
redirect = self.request.route_path("project",
id=model.project_id,
_query={'phase': model.id})
return HTTPFound(redirect)
def add_phase(project, phase_name):
phase = Phase(name=phase_name)
phase.project = project
session = DBSESSION()
session.add(phase)
session.flush()
print u"Added phase to %s: %s" % (project.name, phase_name)
return phase
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 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_editphase(config, dbsession, project, get_csrf_request_with_db):
from autonomie.views.project import PhaseEditFormView
from autonomie.models.project import Phase
phase = Phase(name='test', project=project)
dbsession.merge(phase)
dbsession.flush()
config.add_route('project/{id}', '/')
req = get_csrf_request_with_db()
req.context = phase
view = PhaseEditFormView(req)
view.submit_success({'name': u'Phasé'})
dbsession.flush()
phase = Phase.get(phase.id)
assert (phase.name == u'Phasé')
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 add_internal_number(session, logger):
logger.warn("Adding internal_number to Task")
NUMBER_TMPLS = {
'estimation': u"{s.project.code}_{s.customer.code}_D{s.project_index}\
_{s.date:%m%y}",
'invoice': u"{s.project.code}_{s.customer.code}_F{s.project_index}\
_{s.date:%m%y}",
'cancelinvoice': u"{s.project.code}_{s.customer.code}_A{s.project_index}\
_{s.date:%m%y}"
}
from autonomie.models.task import Task
from autonomie.models.customer import Customer
from autonomie.models.project import Project
from autonomie.models.project import Phase
from sqlalchemy.orm import joinedload
from sqlalchemy.orm import load_only
query = Task.query().options(
load_only("project_index", "company_index", "date", "phase_id", 'type_')
)
query = query.filter(
Task.type_.in_(['invoice', 'estimation', 'cancelinvoice'])
)
query = query.options(joinedload(Task.customer).load_only(Customer.code))
query = query.options(joinedload(Task.project).load_only(Project.code))
for task in query:
tmpl = NUMBER_TMPLS[task.type_]
if Phase.get(task.phase_id) is None:
session.delete(task)
else:
task.internal_number = tmpl.format(s=task).upper()
session.merge(task)
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 add_internal_number(session, logger):
logger.warn("Adding internal_number to Task")
NUMBER_TMPLS = {
'estimation': u"{s.project.code}_{s.customer.code}_D{s.project_index}\
_{s.date:%m%y}",
'invoice': u"{s.project.code}_{s.customer.code}_F{s.project_index}\
_{s.date:%m%y}",
'cancelinvoice': u"{s.project.code}_{s.customer.code}_A{s.project_index}\
_{s.date:%m%y}"
}
from autonomie.models.task import Task
from autonomie.models.customer import Customer
from autonomie.models.project import Project
from autonomie.models.project import Phase
from sqlalchemy.orm import joinedload
from sqlalchemy.orm import load_only
query = Task.query().options(
load_only("project_index", "company_index", "date", "phase_id", 'type_')
)
query = query.filter(
Task.type_.in_(['invoice', 'estimation', 'cancelinvoice'])
)
query = query.options(joinedload(Task.customer).load_only(Customer.code))
query = query.options(joinedload(Task.project).load_only(Project.code))
for task in query:
tmpl = NUMBER_TMPLS[task.type_]
if Phase.get(task.phase_id) is None:
session.delete(task)
else:
task.internal_number = tmpl.format(s=task).upper()
session.merge(task)
def pre_phasechange_process(self, task, status, params):
"""
pre process method for phase changing
"""
form = get_phasechange_form(self.request)
appstruct = form.validate(params.items())
log.debug(u" * Form has been validated")
phase_id = appstruct.get('phase')
phase = Phase.get(phase_id)
appstruct['phase'] = phase
return appstruct
def test_addphase(config, dbsession, project, get_csrf_request_with_db):
from autonomie.views.project import PhaseAddFormView
from autonomie.models.project import Phase
config.add_route('project/{id}', '/')
req = get_csrf_request_with_db()
req.context = project
view = PhaseAddFormView(req)
view.submit_success({'name': u'Phasé'})
dbsession.flush()
phases = Phase.query().filter(Phase.project==project).all()
assert(len(phases) == 2)
def test_addphase(config, dbsession, project, get_csrf_request_with_db):
from autonomie.views.project import PhaseAddFormView
from autonomie.models.project import Phase
config.add_route('project/{id}', '/')
req = get_csrf_request_with_db()
req.context = project
view = PhaseAddFormView(req)
view.submit_success({'name': u'Phasé'})
dbsession.flush()
phases = Phase.query().filter(Phase.project == project).all()
assert (len(phases) == 2)
def __call__(self):
phase_id = self.request.params.get('phase')
if phase_id:
phase = Phase.get(phase_id)
if phase in self.context.project.phases:
self.context.phase_id = phase_id
self.request.dbsession.merge(self.context)
return HTTPFound(
self.request.route_path(PROJECT_ITEM_PHASE_ROUTE,
id=self.context.project_id,
_query={'phase': phase_id}))
def project_addphase(request):
"""
Add a phase to the current project
"""
#TODO : utiliser deform pour manager l'ajout de phase (pour le principe)
# This one should be a Form View
project = request.context
if not request.params.get('phase'):
request.session.flash(u"Le nom de la phase est obligatoire",
queue='error')
anchor = "showphase"
else:
phasename = request.params.get('phase')
phase = Phase()
phase.name = phasename
phase.project_id = project.id
request.dbsession.add(phase)
request.session.flash(u"La phase {0} a bien été \
rajoutée".format(phasename))
anchor = ""
return HTTPFound(request.route_path('project', id=project.id,
_anchor=anchor))
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 test_editphase(config, dbsession, project, get_csrf_request_with_db):
from autonomie.views.project import PhaseEditFormView
from autonomie.models.project import Phase
phase = Phase(name='test', project=project)
dbsession.merge(phase)
dbsession.flush()
config.add_route('project/{id}', '/')
req = get_csrf_request_with_db()
req.context = phase
view = PhaseEditFormView(req)
view.submit_success({'name': u'Phasé'})
dbsession.flush()
phase = Phase.get(phase.id)
assert(phase.name == u'Phasé')
def __call__(self):
phase_id = self.request.params.get('phase')
if phase_id:
phase = Phase.get(phase_id)
if phase in self.context.project.phases:
self.context.phase_id = phase_id
self.request.dbsession.merge(self.context)
return HTTPFound(
self.request.route_path(
PROJECT_ITEM_PHASE_ROUTE,
id=self.context.project_id,
_query={'phase': phase_id}
)
)
def submit_success(self, appstruct):
"""
Add a project with a default phase in the database
"""
# It's an add form
model = self.schema.objectify(appstruct)
model.company = self.context
# Add a default phase to the project
default_phase = Phase()
model.phases.append(default_phase)
self.dbsession.add(model)
self.dbsession.flush()
self.session.flash(self.validation_msg)
return HTTPFound(self.request.route_path('project', id=model.id))
def get_latest_phase(request, phases):
"""
Return the phase where we can identify the last modification
:param list phases: The list of phases of the given project
"""
result = 0
if 'phase' in request.GET:
result = Phase.get(request.GET['phase'])
else:
# We get the latest used task and so we get the latest used phase
all_tasks = []
for phase in phases:
all_tasks.extend(phase.tasks)
all_tasks.sort(key=lambda task: task.status_date, reverse=True)
if all_tasks:
result = all_tasks[0].phase
return result
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 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 get_all_phases(request):
project_ids = [p.id for p in get_all_projects(request)]
return Phase.query().filter(Phase.project_id.in_(project_ids)).all()
def project(content):
proj = Project.query().first()
proj.code = "PRO1"
proj.phases.append(Phase(name="test"))
return proj
def get_all_phases(request):
project_ids = [p.id for p in get_all_projects(request)]
return Phase.query().filter(Phase.project_id.in_(project_ids)).all()
def phase(content):
return Phase.query().first()
def phase(content):
return Phase.query().first()
