def createItemFromTemplate(self, templateUID):
'''The user wants to create an item from a item template that lies in
this meeting configuration. Item id is in the request.'''
templateItem = uuidToObject(templateUID, unrestricted=True)
# Create the new item by duplicating the template item
member_id = get_current_user_id()
template_path_and_title = safe_unicode(
self._template_path_and_title(templateItem))
cloneEventActionLabel = translate(
'create_meeting_item_from_template_label_comments',
domain='imio.history',
mapping={
'template_path_and_title': template_path_and_title,
},
context=self.request)
# if a proposingGroup is defined on itemTemplate and current user is creator
# for this proposingGroup, we keep it
keepProposingGroup = False
proposingGroup = templateItem.getProposingGroup()
if get_plone_group_id(
proposingGroup,
'creators') in self.tool.get_plone_groups_for_user():
keepProposingGroup = True
newItem = templateItem.clone(
newOwnerId=member_id,
cloneEventAction='create_meeting_item_from_template',
cloneEventActionLabel=cloneEventActionLabel,
destFolder=self.context,
newPortalType=self.cfg.getItemTypeName(),
keepProposingGroup=keepProposingGroup,
keep_ftw_labels=True)
# set _at_creation_flag to True so if user cancel first edit, it will be removed
newItem._at_creation_flag = True
return newItem
def _changeCompleteness(self,
new_completeness_value,
bypassSecurityCheck=False,
comment=''):
'''Helper method that change completeness and manage completeness history.'''
# make sure new_completeness_value exists in MeetingItem.listCompleteness vocabulary
if new_completeness_value not in self.context.listCompleteness():
raise KeyError(
"New value %s does not correspond to a value of MeetingItem.listCompleteness"
)
if not bypassSecurityCheck and new_completeness_value not in \
self.context.unrestrictedTraverse('@@item-completeness').listSelectableCompleteness():
raise Unauthorized
self.context.setCompleteness(new_completeness_value)
# add a line to the item's completeness_changes_history
member_id = get_current_user_id()
history_data = {
'action': new_completeness_value,
'actor': member_id,
'time': DateTime(),
'comments': comment
}
self.context.completeness_changes_history.append(history_data)
self.context._update_after_edit(idxs=['getCompleteness'])
def __call___cachekey(method, self, context):
'''cachekey method for self.__call__.'''
date = get_cachekey_volatile(
'Products.PloneMeeting.vocabularies.ftwlabelsforfacetedfiltervocabulary'
)
tool = api.portal.get_tool('portal_plonemeeting')
cfg = tool.getMeetingConfig(context)
# personal labels include current user id
return date, cfg.getId(), cfg.modified(), get_current_user_id(
context.REQUEST)
def handleSaveAdviceDelay(self, action):
data, errors = self.extractData()
if errors:
self.status = self.formErrorsMessage
return
# check that given 'new_advice_delay' is available
# if not available, just raise Unauthorized
tool = api.portal.get_tool('portal_plonemeeting')
cfg = tool.getMeetingConfig(self.context)
newAdviceData = self.getDataForRowId(data['new_delay_row_id'])
currentAdviceData = self.getDataForRowId(data['current_delay_row_id'])
listAvailableDelaysView = self.context.unrestrictedTraverse('@@advice-available-delays')
listAvailableDelaysView._initAttributes(currentAdviceData['org'])
isAutomatic, linkedRows = cfg._findLinkedRowsFor(data['current_delay_row_id'])
selectableDelays = listAvailableDelaysView.listSelectableDelays()
# selectableDelays is a list of tuple containing 3 elements, the first is the row_id
selectableDelays = [selectableDelay[0] for selectableDelay in selectableDelays]
if not data['new_delay_row_id'] in selectableDelays:
raise Unauthorized
# update the advice with new delay and relevant data
# just keep relevant infos
dataToUpdate = ('delay',
'delay_label',
'gives_auto_advice_on_help_message',
'row_id')
for elt in dataToUpdate:
self.context.adviceIndex[currentAdviceData['org']][elt] = newAdviceData[elt]
# if the advice was already given, we need to update row_id on the given advice object too
if not self.context.adviceIndex[currentAdviceData['org']]['type'] == NOT_GIVEN_ADVICE_VALUE:
adviceObj = getattr(self.context, self.context.adviceIndex[currentAdviceData['org']]['advice_id'])
adviceObj.advice_row_id = newAdviceData['row_id']
# if it is an optional advice, update the MeetingItem.optionalAdvisers
if not isAutomatic:
optionalAdvisers = list(self.context.getOptionalAdvisers(computed=True))
# remove old value
optionalAdvisers.remove('%s__rowid__%s' % (currentAdviceData['org'],
currentAdviceData['row_id']))
# append new value
optionalAdvisers.append('%s__rowid__%s' % (newAdviceData['org'],
newAdviceData['row_id']))
self.context.setOptionalAdvisers(tuple(optionalAdvisers))
else:
# if it is an automatic advice, set the 'delay_for_automatic_adviser_changed_manually' to True
self.context.adviceIndex[currentAdviceData['org']]['delay_for_automatic_adviser_changed_manually'] = True
self.context.update_local_roles()
# add a line to the item's adviceIndex advice delay_changes_history
member_id = get_current_user_id()
history_data = {'action': (currentAdviceData['delay'], newAdviceData['delay']),
'actor': member_id,
'time': DateTime(),
'comments': data['comment']}
self.context.adviceIndex[currentAdviceData['org']]['delay_changes_history'].append(history_data)
self.request.response.redirect(self.context.absolute_url() + '/#adviceAndAnnexes')
def __call__(self, context):
context = get_context_with_request(context)
tool = api.portal.get_tool('portal_plonemeeting')
cfg = tool.getMeetingConfig(context)
member_id = get_current_user_id(context.REQUEST)
res = []
labels = ILabelJar(cfg).list()
for label in labels:
if label['by_user']:
res.append(
SimpleTerm('{0}:{1}'.format(member_id, label['label_id']),
'{0}:{1}'.format(member_id, label['label_id']),
'{0} (*)'.format(label['title'])))
else:
res.append(
SimpleTerm(label['label_id'], label['label_id'],
label['title']))
return SimpleVocabulary(res)
def __call__(self):
''' '''
delayChangesView = self.context.unrestrictedTraverse('@@advice-available-delays')
advice_uid = self.request.get('advice')
if not delayChangesView._mayReinitializeDelay(advice_uid):
raise Unauthorized
# reinit delay and add a line to the item's adviceIndex advice delay_changes_history
_reinit_advice_delay(self.context, advice_uid)
member_id = get_current_user_id()
history_data = {'action': 'Reinitiatlize delay',
'actor': member_id,
'time': DateTime(),
'comments': None}
adviceInfos = self.context.adviceIndex[advice_uid]
adviceInfos['delay_changes_history'].append(history_data)
# update local roles that will update adviceIndex
self.context.update_local_roles()
api.portal.show_message(_('Advice delay have been reinitialized for advice "${advice}"',
mapping={'advice': adviceInfos['name']}), request=self.request)
def _doApply(self, data):
""" """
tool = api.portal.get_tool('portal_plonemeeting')
user_id = get_current_user_id()
cloneEventAction = DUPLICATE_EVENT_ACTION
setCurrentAsPredecessor = False
manualLinkToPredecessor = False
if data['keep_link']:
cloneEventAction = DUPLICATE_AND_KEEP_LINK_EVENT_ACTION
setCurrentAsPredecessor = True
manualLinkToPredecessor = True
# make sure data is correct
self._check_data(data)
# as passing empty keptAnnexIds/keptDecisionAnnexIds ignores it
# if we unselect every annexes, we force copyAnnexes/copyDecisionAnnexes to False
copyAnnexes = data['annex_ids'] and True or False
copyDecisionAnnexes = data['annex_decision_ids'] and True or False
# keep proposingGroup if current user creator for it
keepProposingGroup = False
proposingGroup = self.context.getProposingGroup()
if get_plone_group_id(proposingGroup,
'creators') in tool.get_plone_groups_for_user():
keepProposingGroup = True
newItem = self.context.clone(
copyAnnexes=copyAnnexes,
copyDecisionAnnexes=copyDecisionAnnexes,
newOwnerId=user_id,
cloneEventAction=cloneEventAction,
keepProposingGroup=keepProposingGroup,
setCurrentAsPredecessor=setCurrentAsPredecessor,
manualLinkToPredecessor=manualLinkToPredecessor,
keptAnnexIds=data['annex_ids'],
keptDecisionAnnexIds=data['annex_decision_ids'])
self.new_item_url = newItem.absolute_url()
api.portal.show_message(translate('item_duplicated',
domain='PloneMeeting',
context=self.request),
request=self.request)
self._finished = True
return newItem
def _utilsGetCurrentUserId(self, times=1):
''' '''
for time in range(times):
get_current_user_id()
def toggle(self, takenOverByFrom):
if not self.context.adapted().mayTakeOver():
raise Unauthorized
memberId = get_current_user_id()
tool = api.portal.get_tool('portal_plonemeeting')
currentlyTakenOverBy = self.context.getTakenOverBy()
if currentlyTakenOverBy and \
not currentlyTakenOverBy == takenOverByFrom and \
not currentlyTakenOverBy == memberId:
plone_utils = api.portal.get_tool('plone_utils')
plone_utils.addPortalMessage(self.context.translate(
"The item you tried to take over was already taken "
"over in between by ${fullname}. You can take it over "
"now if you are sure that the other user do not handle it.",
mapping={
'fullname':
unicode(tool.getUserName(currentlyTakenOverBy), 'utf-8')
},
domain="PloneMeeting"),
type='warning')
self.request.RESPONSE.status = 500
return
# toggle value
if not currentlyTakenOverBy:
self.context.setTakenOverBy(memberId)
newlyTakenOverBy = memberId
else:
self.context.setTakenOverBy('')
newlyTakenOverBy = ''
css_class = 'takenOverByNobody'
name = 'takenOverByNo'
title_msgid = 'taken_over_by_no_edit'
if newlyTakenOverBy:
if memberId == newlyTakenOverBy:
css_class = 'takenOverByCurrentUser'
else:
css_class = 'takenOverByOtherUser'
name = 'takenOverByYes'
title_msgid = 'taken_over_by_yes_edit'
title = translate(title_msgid,
domain="PloneMeeting",
context=self.request)
if newlyTakenOverBy:
taken_over_by = translate('Taken over by ${fullname}',
mapping={
'fullname':
unicode(tool.getUserName(memberId),
'utf-8')
},
domain="PloneMeeting",
default="Taken over by ${fullname}",
context=self.request)
else:
taken_over_by = translate('(Nobody)',
domain="PloneMeeting",
default="(Nobody)",
context=self.request)
html = self.IMG_TEMPLATE % (css_class, title, name, taken_over_by)
# do not notifyModifiedAndReindex because an item may be taken over
# when it is decided, by members of the proposingGroup
# and in this case item must not be modified
# cache will be invalidated because we check for modified and _p_mtime
reindex_object(self.context,
idxs=['getTakenOverBy'],
update_metadata=False)
return html
