def getCSSClasses(self, item):
css = self.cssClasses.copy()
value = self.getValue(item)
if value and value != self.ignored_value:
if getProjectSpace(self.context).colorize_project_rows and 'interne' in item.categories[0]:
css.update({'tr': 'volet_interne'})
return css
def manage_fields(the_form, portal_type, mode):
"""
Remove, reorder and restrict fields
"""
fields_schemas = getattr(getProjectSpace(the_form.context),
'{}_fields'.format(portal_type), [])
if not fields_schemas:
return
to_input = []
to_display = []
for fields_schema in reversed(fields_schemas):
field_name = fields_schema['field_name']
read_condition = fields_schema.get('read_tal_condition') or ""
write_condition = fields_schema.get('write_tal_condition') or ""
if _evaluateExpression(the_form.context, expression=read_condition):
to_display.append(field_name)
if _evaluateExpression(the_form.context, expression=write_condition):
to_input.append(field_name)
field = remove(the_form, field_name)
if field is not None and field_name in to_display:
add(the_form, field, index=0)
if mode != 'view' and field_name not in to_input:
field.mode = "display"
for group in [the_form] + the_form.groups:
for field_name in group.fields:
if field_name == 'reference_number' and mode != 'view':
continue
if field_name not in to_display:
group.fields = group.fields.omit(field_name)
def update_reference_number(
self,
ptypes='strategicobjective|operationalobjective|pstaction',
doit=''):
"""
Correct reference numbers
"""
if not check_zope_admin():
return "You must be a zope manager to run this script"
out = []
# search regarding context
types = ptypes.split('|')
ps = getProjectSpace(self)
out.append("Working on projectspace {}".format(ps))
out.append('Searching on context {} for types {}'.format(self, types))
brains = api.content.find(context=self, portal_type=types, sort_on='path')
nref = ps.last_reference_number
for brain in brains:
nref += 1
obj = brain.getObject()
out.append("Changing ref from '{}' to {} on '{}'".format(
obj.reference_number, nref, brain.getPath()))
if doit == '1':
obj.reference_number = nref
obj.reindexObject()
if doit == '1':
ps.last_reference_number = nref
return '\n'.join(out)
def href(self):
pst = getProjectSpace(self.context)
if IProject.providedBy(
self.context): # TODO: test if context is descendant of pst ?
return "{0}/sitemap?came_from={1}".format(
pst.absolute_url(),
self.context.UID(),
)
else:
return "{0}/sitemap".format(pst.absolute_url(), )
def __call__(self, context):
""""""
projectspace = getProjectSpace(context)
terms = []
for plan in projectspace.plan_values or []:
terms.append(SimpleTerm(
plan['key'],
plan['key'],
plan['label'],
))
return SimpleVocabulary(terms)
def __call__(self, context):
""""""
projectspace = getProjectSpace(context)
terms = []
for priority in projectspace.priority_values:
terms.append(
SimpleTerm(
priority['key'],
priority['key'],
priority['label'],
))
return SimpleVocabulary(terms)
def __call__(self, context):
""""""
projectspace = getProjectSpace(context)
terms = []
for category in projectspace.categories_values:
terms.append(
SimpleTerm(
category['key'],
category['key'],
category['label'],
))
return SimpleVocabulary(terms)
def __call__(self, context):
""""""
projectspace = getProjectSpace(None)
terms = []
budget_types = projectspace.budget_types
for budget_type in budget_types:
terms.append(
SimpleTerm(
budget_type['key'],
budget_type['key'],
budget_type['label'],
))
return SimpleVocabulary(terms)
def default_year(context):
"""
defaultFactory for the field IBudgetSchema.year
"""
years = getProjectSpace(None).budget_years or []
year = datetime.date.today().year
if year in years:
return year
elif year + 1 in years:
return year + 1
elif years:
return years[-1]
else:
return None
def init_hv(self):
""" init method to be called in document """
def _cleanup_fields(field_schemas):
"""Handle some cases like IDublinCore.title to just keep title"""
return [field_schema['field_name'].split('.')[-1] for field_schema in field_schemas]
projectspace = getProjectSpace(self.real_context)
self.activated_fields = {
'so': _cleanup_fields(projectspace.strategicobjective_fields),
'oo': _cleanup_fields(projectspace.operationalobjective_fields),
'ac': _cleanup_fields(projectspace.pstaction_fields),
'sb': _cleanup_fields(projectspace.pstsubaction_fields),
}
def onAddProject(obj, event):
"""
Handler when a project is added
"""
# compute reference number
if not base_hasattr(obj, 'symbolic_link'):
projectspace = getProjectSpace(obj)
projectspace.last_reference_number += 1
obj.reference_number = projectspace.last_reference_number
obj.reindexObject(['reference_number'])
# refresh budget split lines
if base_hasattr(obj, 'budget_split'):
update_budget_splits(obj, event)
# Update field data on every parents
pw = obj.portal_workflow
workflows = pw.getWorkflowsFor(obj)
if not workflows or pw.getInfoFor(
obj, 'review_state') in get_budget_states(obj):
_updateSummarizedFields(obj)
def getGlobalBudgetByYear(self):
"""
Return a dictionary containing globalized budgets per year
"""
# initialize the dictionary in the year range defined by the project space
fixed_years = [y for y in getProjectSpace(self.real_context).budget_years or []]
budget_by_year = {year: 0 for year in fixed_years}
# get the persistent dict
annotations = IAnnotations(self.real_context)
# get the children budget amounts
if CBIAK in annotations:
globalised_budget = annotations[CBIAK]
for child in globalised_budget:
for budget in globalised_budget[child]:
if budget['year'] in fixed_years:
budget_by_year[budget['year']] += budget['amount']
# get the current element budget amounts
for budget in self.real_context.budget:
if budget['year'] in fixed_years:
budget_by_year[budget['year']] += budget['amount']
return budget_by_year
def get_criteria_holder(context):
pst = getProjectSpace(context)
if IProjectSpace.providedBy(context):
return pst.strategicobjectives
elif context.portal_type == 'strategicobjective':
return pst.operationalobjectives
elif context.portal_type == 'operationalobjective':
return pst.pstactions
elif context.portal_type == 'pstaction':
if context.listFolderContents({'portal_type': 'pstsubaction'}):
context.REQUEST.set('has_subaction', True)
return pst.pstactions
else:
context.REQUEST.set('has_subaction', False)
return pst.tasks
elif context.portal_type == 'pstsubaction':
return pst.tasks
elif not IFacetedNavigable.providedBy(context):
return pst
return context
def perform_reference_number(self):
"""
Add or update the reference_number index
compute the reference_number per projectspace
store the last_reference_number in projectspace
update catalog
"""
logger.info('Perform reference number ...')
addOrUpdateIndexes(self.context, {'reference_number': ('FieldIndex', {})})
catalog = api.portal.get_tool('portal_catalog')
projectspaces = catalog(object_provides=IProjectSpace.__identifier__)
for projectspace in projectspaces:
path = '/'.join(self.portal.getPhysicalPath()) + '/' + projectspace.id
brains = catalog(object_provides=IProject.__identifier__, path={'query': path, 'depth': 3}, sort_on='created')
for num, brain in enumerate(brains):
obj = brain.getObject()
if obj.reference_number == 0:
obj.reference_number = num + 1
obj.reindexObject()
projectspace = getProjectSpace(obj)
projectspace.last_reference_number = num + 1
logger.info('Done.')
def Title(self):
if getattr(getProjectSpace(self), 'use_ref_number', True):
return '%s (OS.%s)' % (self.title.encode('utf8'),
self.reference_number)
else:
return self.title.encode('utf8')
def __call__(self, context):
""""""
years = getProjectSpace(None).budget_years or []
return SimpleVocabulary([SimpleTerm(y) for y in years])
def prepareBudgetInfosForDisplay(self,
only_used_years=False,
only_used_budget_types=False):
"""
Compute budget infos so it can be easily displayed by 'budgetinfos_datagridfield_display.pt'
We need totals by budget_type and year to display something like :
[budget_type/years][Global][2010][2011][2012][2013][2014][2015][2016]
[budget_type_1 ][ 5][ 0][ 0][ 5][ -][ -][ -][ -]
[budget_type_2 ][ 5][ 0][ 0][ 5][ -][ -][ -][ -]
[budget_type_3 ][ 5][ 0][ 0][ 5][ -][ -][ -][ -]
[budget_type_4 ][ 5][ 0][ 0][ 5][ -][ -][ -][ -]
[budget_type_5 ][ 5][ 0][ 0][ 5][ -][ -][ -][ -]
[budget_type_6 ][ 7][ 0][ 2][ 5][ -][ -][ -][ -]
[budget_type_7 ][ 8][ 1][ 2][ 5][ -][ -][ -][ -]
[TOTAL ][ 40][ 1][ 4][ 35][ -][ -][ -][ -]
We will return 5 values :
- list of years sorted (years)
- budget_types sorted (budget_types) : {'budget_type_id1': 'Budget type 1 title',
'budget_type_id2': 'Budget type 2 title',}
- total_by_year : {2010: 125,
2011: 258,}
-total_by_budget_type : {'budget_type1': 258,
'budget_type1': 885,}
- a dict that will appear like this :
{2010: {'budget_type1': 125,
'budget_type2': 250,
'total': 375},
2011: {'budget_type1': 50,
'budget_type2': 1222,
'total': 1272},
'total_years': 1647
}
If p_only_used_years is True, we will return only years that were
used not a fixed list of years, same if p_only_used_budget_types is True,
we will only return used budget_types, not every existing one.
"""
annotations = IAnnotations(self.context)
if not CHILDREN_BUDGET_INFOS_ANNOTATION_KEY in annotations:
return {}
# get budget_types vocabulary so we can have a value to display as saved data is the key
factory = queryUtility(
IVocabularyFactory,
u'imio.project.core.content.project.budget_type_vocabulary')
budgetTypesVocab = factory(self.context)
fixed_years = [
str(y) for y in getProjectSpace(self.context).budget_years or []
]
res = {}
years = only_used_years and [] or fixed_years
budget_types = only_used_budget_types and {} or budgetTypesVocab.by_value
total_by_year = {}
total_by_budget_type = {}
for datagridfieldrecord in annotations[
CHILDREN_BUDGET_INFOS_ANNOTATION_KEY].itervalues():
for line in datagridfieldrecord:
year = str(line['year'])
budget_type = line['budget_type']
amount = line['amount']
# manage used years
if only_used_years and not year in years:
years.append(year)
# manage used budget_types
if only_used_budget_types and not budget_type in budget_types:
budget_types[budget_type] = budgetTypesVocab.getTerm(
budget_type)
# manage total by year/budget_type
if not year in res:
res[year] = {}
if not budget_type in res[year]:
res[year][budget_type] = 0
res[year][budget_type] = res[year][budget_type] + amount
# manage total by year
if not year in total_by_year:
total_by_year[year] = 0
total_by_year[year] = total_by_year[year] + amount
# manage total by budget_type
if not budget_type in total_by_budget_type:
total_by_budget_type[budget_type] = 0
total_by_budget_type[
budget_type] = total_by_budget_type[budget_type] + amount
# make sure with have a result for every year if we use fixed_years
for year in years:
if not year in res:
res[year] = {}
for budget_type in budget_types:
res[year][budget_type] = '-'
# make sure we have each budget_type for each year
for line in res.itervalues():
for budget_type in budget_types:
if not budget_type in line:
line[budget_type] = '-'
# make sure we have each total for each budget_type in total_by_budget_type
for budget_type in budget_types:
if not budget_type in total_by_budget_type:
total_by_budget_type[budget_type] = '-'
# compute super total, meaning total of total_by_years
# (that is the same than total of total_by_budget_types)
super_total = 0
for total in total_by_year.values():
super_total = super_total + total
return years, budget_types, res, total_by_year, total_by_budget_type, super_total
def budget_years(self):
return [
str(y) for y in getProjectSpace(self.context).budget_years or []
]