def setPolicy(self, policy_in, skip_update_role_mappings=False):
context = self.context
config = get_workflow_policy_config(context)
if config is None:
addP = context.manage_addProduct['CMFPlacefulWorkflow']
addP.manage_addWorkflowPolicyConfig()
config = get_workflow_policy_config(context)
wftool = getToolByName(context, 'portal_workflow')
update_role_mappings = False
if self.getCurrentPolicyId() != policy_in:
config.manage_makeChanges(policy_in, policy_in)
update_role_mappings = True
# we may have to change state of the context object
policy_data = self._getPolicyData()
context_trans = policy_data[policy_in].get('context_trans')
for available_trans in wftool.getTransitionsFor(context):
if context_trans == available_trans['id']:
wftool.doActionFor(context, context_trans)
update_role_mappings = True
break
if skip_update_role_mappings:
return update_role_mappings
elif update_role_mappings:
count = self._perform_role_mappings_update()
else:
count = 0
return count
def test_placefulworkflow(self):
pwf_tool = getToolByName(self.portal, 'portal_placeful_workflow')
for wf_id in PLACEFUL_POLICIES.keys():
self.failIf(wf_id not in pwf_tool.objectIds())
project_wf_config = get_workflow_policy_config(self.portal.projects)
self.failUnless(project_wf_config)
self.failUnless(project_wf_config.getPolicyBelowId())
def joinAndApprove(self, mem=None, made_active_date=None, unlisted=False):
"""
this makes the currently logged in user (or the provided user)
a member of this team, forcefully, and optionally backdate the
membership
"""
mship = self._createMembership(mem=mem)
wftool = getToolByName(self, 'portal_workflow')
# XXX hack around workflow transition
# pretend we execucted approve_public
pwft = getToolByName(self, 'portal_placeful_workflow')
config = get_workflow_policy_config(self)
if config is not None:
wfids = config.getPlacefulChainFor('OpenMembership')
wfid = wfids[0]
else:
wfid = 'openplans_team_membership_workflow'
status = wftool.getStatusOf(wfid, mship)
status['review_state'] = 'public'
status['action'] = 'approve_public'
wftool.setStatusOf(wfid, mship, status)
if unlisted is True:
wftool.doActionFor(mship, "make_private")
# follow up like OpenPlans.Extensions.workflow.mship_activated()
mship.made_active_date = DateTime(made_active_date)
mship.reindexObject()
mship._p_changed = True
def install_team_placeful_workflow_policies(portal, out=None):
print >> out, 'Installing team placeful workflow policies'
# Install default policy
try:
pwf_tool = getToolByName(portal, 'portal_placeful_workflow')
teams = getToolByName(portal, 'portal_teams')
except:
pwf_tool = getToolByName(portal._site, 'portal_placeful_workflow')
teams = getToolByName(portal._site, 'portal_teams')
wf_config = get_workflow_policy_config(teams)
if wf_config is None:
print >> out, 'Setting default team security policy to Open'
teams.manage_addProduct['CMFPlacefulWorkflow'].manage_addWorkflowPolicyConfig()
wf_config = get_workflow_policy_config(teams)
wf_config.setPolicyBelow(policy='mship_open_policy')
wf_tool = getToolByName(teams, 'portal_workflow')
wf_tool.updateRoleMappings()
def canApprove(self, dest_state=None):
"""
Determines whether the currently authenticated user has the
right to approve this membership for a given team.
o dest_state - the intended destination state of the
transition being evaluated; used to ensure that only the
transition that results in the desired membership visibility
is exposed
"""
if getattr(self, '_v_self_approved', False):
return True
if dest_state is not None and \
dest_state != self.intended_visibility:
return False
mtool = getToolByName(self, 'portal_membership')
wftool = getToolByName(self, 'portal_workflow')
pwft = getToolByName(self, 'portal_placeful_workflow')
config = get_workflow_policy_config(self.getTeam())
if config is not None:
wfids = config.getPlacefulChainFor('OpenMembership')
# only one in chain
wfid = wfids[0]
else:
wfid = 'openplans_team_membership_workflow'
wf_hist = wftool.getHistoryOf(wfid, self)
last_transition = wf_hist[-1]
review_state = last_transition.get('review_state')
if review_state == 'pending':
auth_mem = mtool.getAuthenticatedMember()
owner_id = self.owner_info()['id']
actor_id = last_transition.get('actor')
if actor_id == owner_id:
# requires project admin approval
can = mtool.checkPermission(ManageTeamMembership,
self.getTeam())
else:
# requires member approval
can = (owner_id == auth_mem.getId()) or \
mtool.checkPermission(ManagePortal, self.getTeam())
elif review_state == 'rejected_by_admin':
can = mtool.checkPermission(ManageTeamMembership, self.getTeam())
elif review_state == 'rejected_by_owner':
auth_mem = mtool.getAuthenticatedMember()
owner_id = self.owner_info()['id']
can = owner_id == auth_mem.getId()
return bool(can)
def getCurrentPolicyId(self, ob=None):
if ob is None:
ob = self.context
wf_id = ''
config = get_workflow_policy_config(ob)
if config is not None:
wf_id = config.getPolicyInId()
else:
# Get the default from the container via acquisition
config = aq_get(aq_inner(ob), WorkflowPolicyConfig_id, None)
if config is not None:
wf_id = config.getPolicyBelowId()
return wf_id
def addProjectsFolder(portal, out=None):
if not 'projects' in portal.objectIds():
print >> out, 'Creating projects folder'
ttool = getToolByName(portal, 'portal_types')
ttool.constructContent('Large Plone Folder', portal,
'projects', title='Projects')
pfolder = portal._getOb('projects')
wftool = getToolByName(portal, 'portal_workflow')
pfolder = portal._getOb('projects')
alsoProvides(pfolder, IAddProject)
try:
from opencore.feed.interfaces import ICanFeed
if not ICanFeed.providedBy(pfolder):
alsoProvides(pfolder, ICanFeed)
except ImportError:
pass
# Add type restrictions
print >> out, 'Restricting addable types in Projects Folder'
pfolder.setConstrainTypesMode(1)
pfolder.setLocallyAllowedTypes(['OpenProject'])
pfolder.setImmediatelyAddableTypes(['OpenProject'])
# Install default policy
pwf_tool = getToolByName(pfolder, 'portal_placeful_workflow')
wf_config = get_workflow_policy_config(pfolder)
if wf_config is None:
print >> out, 'Setting default project security policy to Open'
pfolder.manage_addProduct['CMFPlacefulWorkflow'].manage_addWorkflowPolicyConfig()
wf_config = get_workflow_policy_config(pfolder)
wf_config.setPolicyBelow(policy='open_policy')
wf_tool = getToolByName(pfolder, 'portal_workflow')
setupProjectLayout(portal, out)
setProjectFolderPermissions(portal, out)
def remove_invitations(self, targets, fields=None):
"""
Deletes (or deactivates, if there's history to preserve) the
membership objects. Should send notifiers.
"""
mem_ids = targets
wftool = self.get_tool('portal_workflow')
pwft = getToolByName(self, 'portal_placeful_workflow')
deletes = []
sender = _email_sender(self)
msg_subs = {
'project_title': self.context.title,
'project_noun': self.project_noun,
}
msg = sender.constructMailMessage(mship_messages.invitation_retracted,
**msg_subs)
msg_subject = sender.constructMailMessage(
mship_messages.invitation_retracted_subject,
**msg_subs)
ret = {}
for mem_id in mem_ids:
mship = self.team.getMembershipByMemberId(mem_id)
config = get_workflow_policy_config(self.team)
if config is not None:
wf_ids = config.getPlacefulChainFor('OpenMembership')
wf_id = wf_ids[0]
else:
wf_id = 'openplans_team_membership_workflow'
status = wftool.getStatusOf(wf_id, mship)
if status.get('action') == 'reinvite':
# deactivate
wftool.doActionFor(mship, 'deactivate')
else:
# delete
deletes.append(mem_id)
ret[mem_id] = {'action': 'delete'}
if email_confirmation():
sender.sendMail(mem_id, msg=msg, subject=msg_subject)
if deletes:
self.team.manage_delObjects(ids=deletes)
plural = len(mem_ids) != 1
msg = u'Invitation%s removed: %s' % (plural and 's' or '', ', '.join(mem_ids))
self.add_status_message(msg)
return ret
