def __call__(self):
self.request.response.setHeader('Content-Type', 'application/json; charset=utf-8')
form = self.request.form
print form
site = getSite()
respondentid = form.get("respondentid","NULL")
values = {'respondentid':respondentid,
'measurement' : str(form)}
if respondentid in getSite().keys():
print "updating " + respondentid
new_object = getSite()[respondentid]
else:
print "New object " + respondentid
objid = site.invokeFactory("Measurement", respondentid)
# objid = _createObjectByType("Measurement", getSite(), respondentid)
new_object = site[objid]
new_object.setMeasurement(str(form))
# new_object.processForm(metadata=1, values=values)
transaction.commit()
def test_setThreadSite_clearThreadSite(self):
from zope.app.component.localservice import threadSiteSubscriber
from zope.app.component.localservice import clearSite
from zope.app.publication.zopepublication import BeforeTraverseEvent
self.assertEqual(getSite(), None)
# A non-site is traversed
ob = object()
request = object()
ev = BeforeTraverseEvent(ob, request)
threadSiteSubscriber(ev)
self.assertEqual(getSite(), None)
# A site is traversed
ss = ServiceServiceStub()
site = Folder()
site.setSiteManager(ss)
ev = BeforeTraverseEvent(site, request)
threadSiteSubscriber(ev)
self.assertEqual(getSite(), site)
clearSite()
self.assertEqual(getSite(), None)
def update(self):
self.notification = RegistrationNotification(getSite())
super(NotificationsForm, self).update()
request = self.request
if 'form.unsubscribe' in request:
principals = request.get('form.principals', ())
for pid in principals:
self.notification.unsubscribe(pid)
if principals:
IStatusMessage(request).add(
_('Selected users have been unsubscribed.'))
principals = []
auth = getUtility(IAuthentication)
for pid in self.notification.getSubscribers(getSite()):
try:
principal = auth.getPrincipal(pid)
except PrincipalLookupError:
continue
profile = IPersonalProfile(principal)
principals.append(
(profile.title, {'id': pid, 'title': profile.title}))
principals.sort()
self.principals = [info for _t, info in principals]
def get_Video2(self):
if 'video-2' in getSite():
obj = getSite()['video-2']
return obj
else:
return None
def __call__(self, value, *args, **kwargs):
context = getSite()
portal_membership = getToolByName(context, "portal_membership")
user_admin = portal_membership.getMemberById('admin')
# stash the existing security manager so we can restore it
old_security_manager = getSecurityManager()
# create a new context, as the owner of the folder
newSecurityManager(context,user_admin)
portalGroup = getSite().portal_groups
instance = kwargs.get('instance', None)
req = kwargs['REQUEST']
form = req.form
fields = ['Groups_view','Groups_edit','Groups_admin']
for item in fields:
id_grupo = instance.UID() +'-'+item.split('_')[1]
atual = instance.__getattribute__(item)
news = form.get(item)
alterado = set(atual) - set(news)
for j in alterado:
portalGroup.getGroupById(id_grupo).removeMember(j)
# restore the original context
setSecurityManager(old_security_manager)
def get_tool(name=None):
"""Get a portal tool in a simple way.
:param name: [required] Name of the tool you want.
:type name: string
:returns: The tool that was found by name
:Example: :ref:`portal_get_tool_example`
"""
if not name:
raise MissingParameterError("Missing required parameter: name")
try:
return getToolByName(getSite(), name)
except AttributeError:
# get a list of all tools so we can display their names in the error msg
portal = getSite()
tools = []
for id in portal.objectIds():
if id.startswith('portal_'):
tools.append(id)
raise InvalidParameterError(
"Cannot find a tool with name '%s'. \n"
"Available tools are:\n"
"%s" % (name, '\n'.join(tools)))
def get_profile_url(self, principal):
"""Returns the profile url of this `principal`.
"""
if isinstance(principal, User):
portal = getSite()
return '/'.join((portal.portal_url(), '@@user-details',
principal.userid))
elif self.is_inbox(principal):
return None
elif self.is_contact(principal):
contact = self.get_contact(principal, check_permissions=True)
if contact:
return contact.getURL()
else:
return None
elif self.is_user(principal):
portal = getSite()
user = self.get_user(principal)
if user:
return '/'.join((portal.portal_url(), '@@user-details',
user.userid))
else:
# fallback with acl_users folder
portal_membership = getToolByName(portal, 'portal_membership')
member = portal_membership.getMemberById(principal)
if member:
return portal_membership.getMemberById(
principal).getHomeUrl()
return None
def notifyModifiedPlumiVideo(obj ,event):
"""This gets called on IObjectEditedEvent - called whenever the object is edited."""
workflow = getToolByName(obj,'portal_workflow')
state = workflow.getInfoFor(obj,'review_state','')
log = logging.getLogger('plumi.content.subscribers')
log.info("notifyModifiedPlumiVideo... %s in state (%s) with event %s " % (obj.Title(), state, event))
if getSite():
request = getSite().REQUEST
#VISIBLE
if state in ['private','visible'] and request.has_key('form.button.save'):
#call IPlumiWorkflow API to decide if its ready to publish or needs hiding.
# The adapter object will implement the logic for various content types
if IPlumiWorkflow(obj).autoPublishOrHide():
settings = get_settings()
if settings.notifyReviewers:
IPlumiWorkflow(obj).notifyReviewersVideoSubmitted()
IPlumiWorkflow(obj).notifyOwnerVideoSubmitted()
#PENDING , other states..
if request.has_key('video_file_file'): #new video uploaded
log.info('notifyModifiedPlumiVideo: video replaced;')
async = getUtility(IAsyncService)
temp_time = datetime.datetime.now(pytz.UTC) + datetime.timedelta(seconds=2)
try:
job = async.queueJobWithDelay(None, temp_time, setup_metadata, obj)
log.info("job queued: %s" % job)
except Exception as e:
log.error('failed to queue setup_metadata job: %s' % e)
def getProduto(self):
urltool = getSite().portal_url
caminho = urltool.getPortalPath()+'/cardapio';
ctool = getSite().portal_catalog
items = ctool(portal_type='pizzaria.content.produto',
review_state='published',
path=caminho)
return items
def isAvailable(self):
if super(ErrorConfiglet, self).isAvailable():
sm = IComponentLookup(getUtility(IErrorReportingUtility))
if sameProxiedObjects(sm, getSite().getSiteManager()) or \
IFolder.providedBy(getSite().__parent__):
return True
return False
def _load_state(self):
self._loaded = True
self.uid = IUIDStrategy(self.context).getuid()
self.portal = getSite()
altportal = getSite()
self.sender = invitation_sender(self.portal)
self.localize = getToolByName(self.portal, 'translation_service')
self.timefn = self.localize.ulocalized_time
def __init__(self, object):
self.object = object
self.site = getSite()
import logging
self._logger = logging.getLogger('wildcard.migrator')
self._doc = PrettyDocument()
self.sitepath = '/'.join(getSite().getPhysicalPath())
self.objectpath = '/'.join(
object.getPhysicalPath())[len(self.sitepath):]
def getCadastro(self):
membership = getSite().portal_membership
user_login = membership.getAuthenticatedMember()
try:
cadastro= getSite()['clientes'][user_login.id]
except:
cadastro= None
return cadastro
def get_flash_banners(self):
"""Retorna os objetos to tipo banner em determinado local"""
urltool = getSite().portal_url
caminho = urltool.getPortalPath()+'/jornal-da-caixa/banners-do-jornal';
ctool = getSite().portal_catalog
items = ctool(portal_type='BannerFlash',
review_state='published',
path=caminho)
return items
def voc_listGroups(self):
terms = []
if 'acl_users' in getSite().keys():
groups = getSite().get('acl_users').getGroups()
for group in groups:
member_id = group.id
member_name = group.getProperties().get('title','')
terms.append((member_id, unicode(member_name)))
return terms
def update(self):
super(MessageTemplate, self).update()
request, context = self.request, self.context
self.portal_title = getMultiAdapter((getSite(), request), IBreadcrumb).name
self.portal_url = '%s/' % absoluteURL(getSite(), request)
self.url = '%s/' % absoluteURL(context, request)
self.form = getMultiAdapter((context, request), IFormResults)
self.form.update(self.record)
def configurador(self):
self.update()
if "control-panel-objects" in getSite().keys():
control = getSite()["control-panel-objects"]
if "vindula_vindulaconfigall" in control.keys():
return control["vindula_vindulaconfigall"]
else:
return False
else:
return False
def search(self, object=None, contexts=(),
sort_on='date', sort_order='reverse',
noSecurityChecks=False, **kw):
ids = getUtility(IIntIds)
query = dict(kw)
# records for object
if type(object) is not type({}) and object is not None:
oid = ids.queryId(removeAllProxies(object))
if oid is None:
return ResultSet(IFBTree(), getUtility(IActivity))
query['object'] = {'any_of': (oid,)}
# context
if not contexts:
contexts = (getSite(),)
c = []
for context in contexts:
id = ids.queryId(removeAllProxies(context))
if id is not None:
c.append(id)
query['contexts'] = {'any_of': c}
# security
if not noSecurityChecks:
request = getRequest()
if request is not None:
users = listAllowedRoles(request.principal, getSite())
if 'zope.Anonymous' not in users:
users.append('zope.Anonymous')
query['allowedUsers'] = {'any_of': users}
# apply searh terms
results = self.apply(query)
if results is None:
results = IFBTree()
# sort result by index
if sort_on and sort_on in self:
sortable = ISortable(self[sort_on], None)
if sortable is not None:
results = sortable.sort(results)
if sort_order == 'reverse':
return ReverseResultSet(results, getUtility(IActivity))
else:
return ResultSet(results, getUtility(IActivity))
def getListToOrder(self):
result = [('effective', u'Effective Date', 'The time and date an item becomes publicly available'), \
('sortable_title', u'Sortable Title', u"An item's title transformed for sorting")]
if 'control-panel-objects' in getSite().keys():
control = getSite()['control-panel-objects']
if 'vindula_categories' in control.keys():
confg = control['vindula_categories']
try:
for i in confg.getOrder_list():
result.append(i.replace('(', '').replace(')','').replace('u\'', '').replace('\'', '').split(','))
except:
return result
return result
def getConfigurador(self):
if 'control-panel-objects' in getSite().keys():
control = getSite()['control-panel-objects']
if 'ThemeConfig' in control.keys():
confg = control['ThemeConfig']
try:
return confg.getFavicon().absolute_url()
except:
return None
else:
return None
else:
return None
def getSubMenu(self, menu):
portal = self.context.portal_url.getPortalObject()
types = self.getContentTypes()
urltool = getSite().portal_url
caminho = {'query': '/'.join(menu.getPhysicalPath()), 'depth': 1}
ctool = getSite().portal_catalog
submenus = ctool(portal_type=types, path=caminho,sort_on='getObjPositionInParent')
if submenus:
L = []
for obj in submenus:
if self.checkObj(obj.getObject()):
L.append(obj.getObject())
return L
def update(self):
site = getSite()
self.max_online = "Max Concurrent in Single Day :" # "16 on Dec. 3"
self.max_logged = "Max Users in Single Day :"
try:
max_online_count_users_by_month = sorted(site['stats'].count_users_by_month, key=lambda x: x[0], reverse=True)[0]
max_online_count_today = sorted(site['stats'].count_users_allday, key=lambda x: x[0], reverse=True)[0]
if max_online_count_today[0] >= max_online_count_users_by_month[0]:
self.stats_max_online = str(max_online_count_today[0]) + ' ' + self.format_date(max_online_count_today[1], True)
else:
self.stats_max_online = str(max_online_count_users_by_month[0]) + ' ' + self.format_date(max_online_count_users_by_month[1], True)
stats_max_logged_today = len(site['stats'].list_users_names)
stats_max_logged = sorted(site['stats'].count_users_names, key=lambda x: x[0], reverse=True)[0]
if stats_max_logged_today >= stats_max_logged[0]:
self.stats_max_logged = str(stats_max_logged_today) + ' ' + self.format_date(datetime.datetime.now(), False)
else:
self.stats_max_logged = str(stats_max_logged[0]) + ' ' + self.format_date(stats_max_logged[1],False)
except (IndexError,KeyError), e:
try:
max_online_count_today = sorted(site['stats'].count_users_allday, key=lambda x: x[0], reverse=True)[0]
self.stats_max_online = str(max_online_count_today[0]) + ' ' + self.format_date(max_online_count_today[1], True)
stats_max_logged_today = len(site['stats'].list_users_names)
self.stats_max_logged = str(stats_max_logged_today) + ' ' + self.format_date(datetime.datetime.now(), False)
except (IndexError,KeyError, AttributeError), e:
self.stats_max_online = 'None'
self.stats_max_logged = 'None'
def update(self):
quiz = getSite()
int_ids = getUtility(IQreatureIntIds, context=self.context)
ce = getUtility(ICounterExplorer, context=self.context)
results= [r for r in quiz.values() if IQuizResult.providedBy(r)]
self.titles = [r.title.encode('utf-8') for r in results]
self.counters = [ce.getCounter(r, key=int_ids.getId(r)) for r in results]
def notify_configuration_changed(event):
"""Event subscriber that is called every time the configuration changed.
"""
portal = getSite()
wftool = getToolByName(portal, 'portal_workflow', None)
if IRecordModifiedEvent.providedBy(event):
# Discussion control panel setting changed
if event.record.fieldName == 'moderation_enabled':
# Moderation enabled has changed
if event.record.value == True:
# Enable moderation workflow
wftool.setChainForPortalTypes(('Discussion Item',),
'comment_review_workflow')
else:
# Disable moderation workflow
wftool.setChainForPortalTypes(('Discussion Item',),
'one_state_workflow')
if IConfigurationChangedEvent.providedBy(event):
# Types control panel setting changed
if 'workflow' in event.data:
registry = queryUtility(IRegistry)
settings = registry.forInterface(IDiscussionSettings, check=False)
wf = wftool.getChainForPortalType('Discussion Item')[0]
if wf == 'one_state_workflow':
settings.moderation_enabled = False
elif wf == 'comment_review_workflow':
settings.moderation_enabled = True
else:
# Custom workflow
pass
def get_contact(self, principal, check_permissions=False):
"""Returns the contact object of this principal.
"""
if not self.is_contact(principal):
raise ValueError('Principal %s is not a contact' % str(principal))
catalog = getToolByName(getSite(), 'portal_catalog')
query = {'portal_type': 'opengever.contact.contact',
'contactid': principal}
if not check_permissions:
# usually foreign users may not have access to the contacts,
# but we want to be able to print the name etc. in this case too.
# So we need to use ZCatalog for ignoring the allowedRolesAndUsers
# index.
contacts = ZCatalog.searchResults(catalog, **query)
else:
contacts = catalog.searchResults(**query)
if len(contacts) == 0:
return None
elif len(contacts) > 1:
raise ValueError('Found %i contacts with principal %s' % (
len(contacts), principal))
else:
return contacts[0]
def total_width():
return 899.0
default_width = 1000.0
site = getSite()
try:
portal_skins = getToolByName(site, 'portal_skins')
except AttributeError:
return default_width
try:
base_properties = portal_skins.restrictedTraverse('agcommon_styles/base_properties')
except KeyError:
return default_width
width = base_properties.getProperty('maxWidth', '')
if not width:
return default_width
width = re.sub('[A-Za-z]+', '', width)
try:
return float(width)
except ValueError:
return default_width
def language_filter(query):
if query.get('Language') == 'all':
del query['Language']
return
for key in NO_FILTER: # any "nofilter" indexing prevent mangling
if key in query:
return
site = getSite()
languageTool = getToolByName(site, 'portal_languages', None)
if languageTool is None:
return
query['Language'] = [languageTool.getPreferredLanguage(),
LANGUAGE_INDEPENDENT]
old_path = query.get('path', None)
# In case is a depth path search
if isinstance(old_path, dict) and 'query' in old_path and\
IPloneSiteRoot.providedBy(site):
old_path_url = old_path['query']
# We are going to check if is language root
root_path = '/'.join(site.getPhysicalPath())
# Check is a language root folder to add the shared folder
if old_path['query'].split('/')[-1] in _languagelist:
old_path['query'] = [old_path_url, root_path + '/' + SHARED_NAME]
def render_confirmation(self, subscription):
"""
Custom render_confirmation method.
If there is a registered template with id "confirm_newsletter_subscription" use it.
If there isn't, use the default template.
"""
vars = self._vars(subscription)
subscription_vars = self._subscription_vars(subscription)
if 'confirmation_subject' not in vars:
vars['confirmation_subject'] = translate(
_(u"Confirm your subscription with ${channel-title}",
mapping={'channel-title': subscription.channel.title}),
target_language=self.language)
to_addr = subscription_vars[template_var('to_addr')]
vars['to_addr'] = to_addr
portal = getSite()
confirm_template = portal.restrictedTraverse('confirm_newsletter_subscription',
self.confirm_template)
html = confirm_template(**vars)
html = utils.compactify(html)
html = string.Template(html).safe_substitute(subscription_vars)
message = create_html_mail(
vars['confirmation_subject'],
html,
from_addr=vars['from_addr'],
to_addr=to_addr,
headers=vars.get('more_headers'),
encoding=self.encoding)
# status=None prevents message from ending up in any queue
return Message(
message, subscription, status=None)
def render_forgot_secret(self, subscription):
"""
Custom render_forgot method.
If there is a registered template with id "forgot_newsletter_subscription" use it.
If there isn't, use the default template.
"""
vars = self._vars(subscription)
subscription_vars = self._subscription_vars(subscription)
portal = getSite()
if 'forgot_secret_subject' not in vars:
vars['forgot_secret_subject'] = translate(
_(u"Change your subscriptions with ${site_title}",
mapping={'site_title': vars['channel_title']}),
target_language=self.language)
forgot_template = portal.restrictedTraverse('forgot_newsletter_subscription',
self.forgot_template)
html = forgot_template(**vars)
html = utils.compactify(html)
html = string.Template(html).safe_substitute(subscription_vars)
message = create_html_mail(
vars['forgot_secret_subject'],
html,
from_addr=vars['from_addr'],
to_addr=subscription_vars[template_var('to_addr')],
headers=vars.get('more_headers'),
encoding=self.encoding)
# status=None prevents message from ending up in any queue
return Message(
message, subscription, status=None)
def update(self):
context = getSite()
self.context = context
results = getUtility(ICatalog).searchResults(
searchContext=context,
type={'any_of': ('content.space',)},
isDraft={'any_of': (False,)})
count = 1000
spaces = []
for space in results:
url = '%s/'%absoluteURL(space, self.request)
c = url.count('/')
if c < count:
count = c
spaces.append((c, space.title,
{'title': space.title,
'description': space.description,
'url': url,
'level': c,
'space': space}))
spaces.sort()
spaces = [info for c, t, info in spaces]
for info in spaces:
info['level'] = info['level'] - count
self.spaces = spaces
super(SpacesPortlet, self).update()
def _get_site(self):
return zopeappcomponenthooks.getSite()
def __call__(self):
rc = getToolByName(getSite(), 'reference_catalog')
return FullFormatWrapper(rc.lookupObject(self.uid))
def _error_html(self, title, body):
try:
# wrap it all up just in case it screws up
# it'd be even worse to not send a response!
site = getSite()
if not site:
return
from uwosh.default import monkey
now = DateTime()
mailhost = getToolByName(site, 'MailHost', None)
pp = getToolByName(site, 'portal_properties', None)
to_ = pp.site_properties.getProperty('error_recipients', [
'*****@*****.**',
])
req = site.REQUEST
if self.status != 500 and not req.environ.get('HTTP_REFERER', False):
pass
elif not monkey.ERRORS.has_key(req.URL):
monkey.ERRORS[req.URL] = {}
monkey.ERRORS[req.URL]['body'] = body
monkey.ERRORS[req.URL]['status'] = self.status
monkey.ERRORS[req.URL]['number_reported'] = 1
monkey.ERRORS[req.URL]['last_reported'] = DateTime()
monkey.ERRORS[req.URL]['referrer'] = req.environ.get(
'HTTP_REFERER', '')
monkey.ERRORS[req.URL]['email_sent'] = False
else:
monkey.ERRORS[req.URL]['number_reported'] += 1
monkey.ERRORS[req.URL]['last_reported'] = DateTime()
monkey.ERRORS[req.URL]['referrer'] = req.environ.get(
'HTTP_REFERER', '')
if self.status != 500 and (monkey.last_sent_404 + one_day) <= now:
monkey.last_sent_404 = now
body = body + "\n\nComplete set of errors\n\n" + '\n'.join(
[format_error(k, error) for k, error in monkey.ERRORS.items()])
if hasattr(mailhost, 'secureSend'):
mailhost.secureSend(body, to_, '*****@*****.**',
'Plone UW Oshkosh ERROR!')
else:
mailhost.send(body, to_, '*****@*****.**',
'Plone UW Oshkosh ERROR!')
elif self.status == 500 and (monkey.last_sent_500 +
one_minute) <= now and not monkey.ERRORS[
req.URL]['email_sent']:
monkey.last_sent_500 = now
monkey.ERRORS[req.URL]['email_sent'] = True
if hasattr(mailhost, 'secureSend'):
mailhost.secureSend(body, to_, '*****@*****.**',
'Plone UW Oshkosh ERROR!')
else:
mailhost.send(body, to_, '*****@*****.**',
'Plone UW Oshkosh ERROR!')
return error_template.replace('{{title}}',
title).replace('{{body}}', body)
except:
return original_error_html(self, title, body)
def _removeFromWorkList(self):
worklist = zope.component.getUtility(interfaces.IWorkList,
name=self.worklist,
context=getSite())
worklist.remove(self)
def get_url(self, item):
site = getSite()
base_url = absoluteURL(site, self.request)
return base_url + "/business/%ss/obj-%s" % (
item.origin.type, item.origin.parliamentary_item_id)
def update(self):
section = get_section_name()
base_url = abs_url(getSite(), self.request)
if not section:
section = 'business'
self.action = urljoin(base_url, section) + '/search'
def queue_view_helper(item, value):
site = getSite()
return """<a href='%s/jobs_view?queue=%s'>%s</a>""" % (site.absolute_url(),
value, value)
def __str__(self):
base_url = ui_utils.url.absoluteURL(getSite(), self.request)
return '%s/%s/%s/%s' % (base_url, self.section, self.subsection,\
stringKey(self.context))
def getURLContext(self):
site = getSite()
return site["admin"]
def back_to_controlpanel(self):
root = getSite()
return dict(url=root.absolute_url() + '/plone_control_panel')
def __str__(self):
base_url = ui_utils.url.absoluteURL(getSite(), self.request)
return '%s/archive/browse/parliaments/obj-%s/%s/%s' % \
(base_url, self.context.parliament_id, self.subsection, stringKey(self.context))
def initializeAreas(pm_tool, acl_tool, request, member_folder_id=None):
"""
Creates custom content in the member's folder.
Create group spaces and content for the member's groups.
1. Create private space for the user.
2. Create public space for user if they are a member of parliament.
3. Populate the public space with custom content
4. Create group home folder for any groups (except a parliament) this user is a member of.
3.1 Create a private space for the group home folder.
3.2 Create a public space for the group home folder
3.3 Populate the public space with custom content.
"""
portal = getSite()
sm = getSecurityManager()
tmp_user = BaseUnrestrictedUser(sm.getUser().getId(),'', ['Manager'],'')
newSecurityManager(None, tmp_user)
acl_tool = getToolByName(portal, 'acl_users')
if "groups" in portal.objectIds():
groups_space = portal["groups"]
if member_folder_id:
member = pm_tool.getMemberById(decleanId(member_folder_id))
else:
member = pm_tool.getAuthenticatedMember()
member_id = member.getId()
folder = pm_tool.getHomeFolder(member_id)
#All members get a private workspace area.
create_space(folder, "private_space", "Private Space", "private", member_id, member, "PrivateFolder")
member_groupIds = member.getGroupIds()
for member_groupId in member_groupIds:
group_membership_roles = doSearch(acl_tool, member_groupId)
if "bungeni.MP" in group_membership_roles:
create_space(folder, "web_space", "Web Space", "publish", member_id, member, "PublicFolder")
parent_space = getattr(folder, "web_space")
mark(parent_space, IMemberSpace)
parent_space.setLayout("space_view")
create_content(parent_space, MEMBER_SPACE_CONTENT, member, "publish")
groups_space = portal["groups"]
for member_groupId in member_groupIds:
group_membership_roles = doSearch(acl_tool, member_groupId)
#if group home folder does not exist
#it is cheaper to check if the group home folder already exists, then exit if it does
for bungeni_group in acl_tool.bungeni_groups.enumerateGroups():
if (member_groupId == bungeni_group["id"]) and ("bungeni.MP" not in group_membership_roles) and (bungeni_group["id"]not in groups_space.objectIds()):
group = acl_tool.bungeni_groups.getGroupById(bungeni_group["id"])
create_space(groups_space, bungeni_group["id"],
bungeni_group["title"], "private", bungeni_group["id"],
group, "Folder")
parent_space = getattr(groups_space, bungeni_group["id"])
create_space(parent_space, "private_space", "Private Space",
"private", bungeni_group["id"],
group, "PrivateFolder")
create_space(parent_space, "web_space", "Web Space",
"publish", bungeni_group["id"],
group, "PublicFolder")
parent_space = getattr(parent_space, "web_space")
mark(parent_space, IGroupSpace)
parent_space.setLayout("space_view")
create_content(parent_space, GROUP_SPACE_CONTENT, group, "publish")
def dvInstalled():
qi = getToolByName(getSite(), 'portal_quickinstaller', None)
if qi is None:
return False
return qi.isProductInstalled('collective.documentviewer')
def __init__(self, context):
self.context = context
self.catalog = getToolByName(self.context, 'portal_catalog')
self.portal = getSite()
self.portal_url = self.portal.absolute_url()
def __init__(self, context, request):
self.document = removeSecurityProxy(context)
self.site_url = url.absoluteURL(getSite(), request)
super(DownloadDocument, self).__init__(context, request)
def get_services_regexp():
annotations = IAnnotations(getSite())
embedly_re = re.compile(
annotations.get('collective.embedly.services', default_services))
return embedly_re
def quotationtoolURL(self):
# use hooks because component lookup error if error is context
return absoluteURL(hooks.getSite(), self.request)
def __init__(self, context, request):
self.site_url = url.absoluteURL(getSite(), request)
super(ReportView, self).__init__(context, request)
def __call__(self):
self.request.response.expireCookie("wc.cookiecredentials")
site_url = ui_utils.url.absoluteURL(getSite(), self.request)
self.request.response.redirect(site_url)
def url(self):
siteURL = absoluteURL(hooks.getSite(), self.request)
return siteURL + '/' + self.viewURL
def __init__(self, context, request, include_text=True):
self.context = context
self.request = request
self.include_text = include_text
self.site_url = url.absoluteURL(getSite(), request)
def __call__(self):
if IUnauthenticatedPrincipal.providedBy(self.request.principal):
self.request.response.redirect(
ui_utils.url.absoluteURL(getSite(), self.request) + "/login")
return super(ChangePasswordForm, self).__call__()
def __str__(self):
base_url = ui_utils.url.absoluteURL(getSite(), self.request)
return '%s/admin/content/parliaments/obj-%s/%s/%s' % \
(base_url, self.context.group_id, self.subsection, stringKey(self.context))
def get_sitting_items(sitting, request, include_actions=False):
items = []
if sitting.status in get_states("groupsitting",
keys=["draft_agenda", "published_agenda"]):
order = "planned_order"
else:
order = "real_order"
schedulings = map(removeSecurityProxy,
sitting.items.batch(order_by=order, limit=None))
site_url = url.absoluteURL(getSite(), request)
for scheduling in schedulings:
item = ProxyFactory(location_wrapped(scheduling.item, sitting))
props = IDCDescriptiveProperties.providedBy(item) and item or \
IDCDescriptiveProperties(item)
discussions = tuple(scheduling.discussions.values())
discussion = discussions and discussions[0] or None
truncated_discussion = None
if ((discussion is not None) and (discussion.body_text is not None)):
#truncate discussion to first hundred characters
t_discussion = discussion.body_text[0:100]
try:
#truncate discussion to first two lines
index = t_discussion.index("<br>")
index2 = t_discussion.index("<br>", index + 4)
truncated_discussion = t_discussion[0:index2] + "..."
except ValueError:
truncated_discussion = t_discussion + "..."
wfc = IWorkflowController(item, None)
state_title = wfc.workflow.get_state(item.status).title
record = {
'title':
props.title,
'description':
props.description,
'name':
stringKey(scheduling),
'status':
item.status,
'type':
item.type.capitalize,
't':
item.type,
'state_title':
state_title,
#'category_id': scheduling.category_id,
#'category': scheduling.category,
'discussion':
discussion,
'truncated_discussion':
truncated_discussion,
'delete_url':
"%s/delete" % url.absoluteURL(scheduling, request),
'url':
url.set_url_context(site_url +
('/business/%ss/obj-%s' %
(item.type, item.parliamentary_item_id)))
}
if include_actions:
record['actions'] = get_scheduling_actions(scheduling, request)
record['workflow'] = get_workflow_actions(item, request)
discussion_actions = get_discussion_actions(discussion, request)
if discussion_actions:
assert len(discussion_actions) == 1
record['discussion_action'] = discussion_actions[0]
else:
record['discussion_action'] = None
items.append(record)
return items
def ScopeID():
urltool = getToolByName(getSite(), 'portal_url')
obj = urltool.getPortalObject()
return '-'.join(obj.getPhysicalPath()[1:])
def __str__(self):
base_url = ui_utils.url.absoluteURL(getSite(), self.request)
return '%s/admin/content/parties/%s' % (base_url,
stringKey(self.context))
def get_group_context(context):
if interfaces.IOffice.providedBy(context):
return getSite() #get_parliament(context)
else:
return context
def runMigration(context):
"""Run a migration profile as an upgrade step
"""
portal = getSite()
setup_tool = getToolByName(portal, 'portal_setup')
setup_tool.runAllImportStepsFromProfile('profile-collective.easyslideshow:migration-002')
def clear(self):
annotations = IAnnotations(getSite())
if self.propname in annotations:
del annotations[self.propname]
def _appendToWorkList(self):
worklist = zope.component.getUtility(interfaces.IWorkList,
name=self.worklist,
context=getSite())
worklist.append(self)
