def create_sittings_map(sittings, request):
"""Returns a dictionary that maps:
(day, hour) -> {
"record" : sitting database record
"actions" : actions that apply to this sitting
"class" : sitting
"span" : span
}
(day, hour) -> ``None``
If the mapped value is a sitting, then a sitting begins on that
day and hour, if it's ``None``, then a sitting is reaching into
this day and hour.
The utility of the returned structure is to aid rendering a
template with columns spanning several rows.
"""
mapping = {}
for sitting in sittings.values():
day = sitting.start_date.weekday()
hour = sitting.start_date.hour
start_date = utils.timedict(sitting.start_date.hour,
sitting.start_date.minute)
end_date = utils.timedict(sitting.end_date.hour,
sitting.end_date.minute)
status = misc.get_wf_state(sitting)
proxied = ProxyFactory(sitting)
# !+ non-existant permission
if checkPermission(u"bungeni.agenda_item.wf.schedule", proxied):
link = "%s/schedule" % url.absoluteURL(sitting, request)
else:
link = url.absoluteURL(sitting, request)
if checkPermission("bungeni.sitting.View", proxied):
mapping[day, hour] = {
"url": link,
"record": sitting,
"class": u"sitting",
"actions": get_sitting_actions(sitting, request),
"span": sitting.end_date.hour - sitting.start_date.hour,
"formatted_start_time": start_date,
"formatted_end_time": end_date,
"status": status,
}
for hour in range(sitting.start_date.hour + 1,
sitting.end_date.hour):
mapping[day, hour] = None
# make sure start- and end-date is the same DAY
assert (sitting.start_date.day == sitting.end_date.day) and \
(sitting.start_date.month == sitting.end_date.month) and \
(sitting.start_date.year == sitting.end_date.year)
return mapping
async def real_resolve(self, request):
"""Main function to resolve a request."""
alsoProvides(request, IRequest)
alsoProvides(request, IDefaultLayer)
request._futures = {}
request.security = IInteraction(request)
method = app_settings['http_methods'][request.method]
language = language_negotiation(request)
language_object = language(request)
try:
resource, tail = await self.traverse(request)
except Exception as _exc:
request.resource = request.tail = None
request.exc = _exc
# XXX should only should traceback if in some sort of dev mode?
raise HTTPBadRequest(text=json.dumps({
'success': False,
'exception_message': str(_exc),
'exception_type': getattr(type(_exc), '__name__', str(type(_exc))), # noqa
'traceback': traceback.format_exc()
}))
request.resource = resource
request.tail = tail
if request.resource is None:
raise HTTPBadRequest(text='Resource not found')
traverse_to = None
if tail and len(tail) == 1:
view_name = tail[0]
elif tail is None or len(tail) == 0:
view_name = ''
else:
view_name = tail[0]
traverse_to = tail[1:]
await self.apply_authorization(request)
translator = queryMultiAdapter(
(language_object, resource, request),
ITranslated)
if translator is not None:
resource = translator.translate()
# Add anonymous participation
if len(request.security.participations) == 0:
# logger.info("Anonymous User")
request.security.add(AnonymousParticipation(request))
# Site registry lookup
try:
view = queryMultiAdapter(
(resource, request), method, name=view_name)
except AttributeError:
view = None
# Traverse view if its needed
if traverse_to is not None and view is not None:
if not ITraversableView.providedBy(view):
return None
else:
try:
view = view.publishTraverse(traverse_to)
except Exception as e:
logger.error(
"Exception on view execution",
exc_info=e)
return None
permission = getUtility(IPermission, name='plone.AccessContent')
allowed = request.security.checkPermission(permission.id, resource)
if not allowed:
# Check if its a CORS call:
if IOPTIONS != method or not app_settings['cors']:
# Check if the view has permissions explicit
if view is None or not view.__allow_access__:
logger.warn("No access content {content} with {auths}".format(
content=resource,
auths=str([x.principal.id
for x in request.security.participations])))
raise HTTPUnauthorized()
if view is None and method == IOPTIONS:
view = DefaultOPTIONS(resource, request)
checker = getCheckerForInstancesOf(view.__class__)
if checker is not None:
view = ProxyFactory(view, checker)
# We want to check for the content negotiation
renderer = content_type_negotiation(request, resource, view)
renderer_object = renderer(request)
rendered = queryMultiAdapter(
(renderer_object, view, request), IRendered)
if rendered is not None:
return MatchInfo(resource, request, view, rendered)
else:
return None
def setUp(self):
super(TestStructuralSubscriptionForProductSeries, self).setUp()
self.target = self.factory.makeProductSeries()
self.target = ProxyFactory(self.target)
inst.dictionary = dictionary
return inst
@property
def __getitem__(self):
return self.dictionary.__getitem__
@property
def __len__(self):
return self.dictionary.__len__
def __repr__(self):
return "{...} (%d entries)" % len(self)
sys_modules = ProxyFactory(OpaqueDict(sys.modules))
class DummyRegistry(object):
"""This class is for B/W with Chameleon 1.x API."""
@staticmethod
def purge():
pass
class BaseTemplate(template.PageTemplate):
content_type = None
version = 2
registry = DummyRegistry()
def setUp(self):
super(TestStructuralSubscriptionForMilestone, self).setUp()
self.target = self.factory.makeMilestone()
self.target = ProxyFactory(self.target)
def setUp(self):
super(TestStructuralSubscriptionForProjectGroup, self).setUp()
self.target = self.factory.makeProject()
self.target = ProxyFactory(self.target)
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 setUp(self):
super(TestStructuralSubscriptionForDistroSourcePackage, self).setUp()
self.target = self.factory.makeDistributionSourcePackage()
self.target = ProxyFactory(self.target)
def setContext(self, name, value):
# Hook to allow subclasses to do things like adding security proxies
Context.setContext(self, name, ProxyFactory(value))
def getFunctionNamespace(self, namespacename):
""" Returns the function namespace """
return ProxyFactory(
super(ZopeEngine, self).getFunctionNamespace(namespacename))
def branchMergeProposalSetUp(test):
setUp(test, future=True)
factory = LaunchpadObjectFactory()
test.globs['target'] = ProxyFactory(
factory.makeBranchMergeProposalForGit())
def SafeBuiltins():
builtins = {}
from zope.security.checker import NamesChecker
import __builtin__
_builtinTypeChecker = NamesChecker([
'__str__', '__repr__', '__name__', '__module__', '__bases__',
'__call__'
])
# It's better to say what is safe than it say what is not safe
for name in [
# Names of safe objects. See untrustedinterpreter.txt for a
# definition of safe objects.
'ArithmeticError',
'AssertionError',
'AttributeError',
'DeprecationWarning',
'EOFError',
'Ellipsis',
'EnvironmentError',
'Exception',
'FloatingPointError',
'IOError',
'ImportError',
'IndentationError',
'IndexError',
'KeyError',
'KeyboardInterrupt',
'LookupError',
'MemoryError',
'NameError',
'None',
'NotImplemented',
'NotImplementedError',
'OSError',
'OverflowError',
'OverflowWarning',
'ReferenceError',
'RuntimeError',
'RuntimeWarning',
'StandardError',
'StopIteration',
'SyntaxError',
'SyntaxWarning',
'SystemError',
'SystemExit',
'TabError',
'TypeError',
'UnboundLocalError',
'UnicodeError',
'UserWarning',
'ValueError',
'Warning',
'ZeroDivisionError',
'__debug__',
'__name__',
'__doc__',
'abs',
'apply',
'bool',
'buffer',
'callable',
'chr',
'classmethod',
'cmp',
'coerce',
'complex',
'copyright',
'credits',
'delattr',
'dict',
'divmod',
'filter',
'float',
'frozenset',
'getattr',
'hasattr',
'hash',
'hex',
'id',
'int',
'isinstance',
'issubclass',
'iter',
'len',
'license',
'list',
'long',
'map',
'max',
'min',
'object',
'oct',
'ord',
'pow',
'property',
'quit',
'range',
'reduce',
'repr',
'reversed',
'round',
'set',
'setattr',
'slice',
'sorted',
'staticmethod',
'str',
'super',
'tuple',
'type',
'unichr',
'unicode',
'vars',
'xrange',
'zip',
'True',
'False',
# TODO: dir segfaults with a seg fault due to a bad tuple
# check in merge_class_dict in object.c. The assert macro
# seems to be doing the wrong think. Basically, if an object
# has bases, then bases is assumed to be a tuple.
#dir,
]:
try:
value = getattr(__builtin__, name)
except AttributeError:
pass
else:
if isinstance(value, type):
value = ProxyFactory(value, _builtinTypeChecker)
else:
value = ProxyFactory(value)
builtins[name] = value
from sys import modules
def _imp(name, fromlist, prefix=''):
module = modules.get(prefix + name)
if module is not None:
if fromlist or ('.' not in name):
return module
return modules[prefix + name.split('.')[0]]
def __import__(name, globals=None, locals=None, fromlist=()):
# Waaa, we have to emulate __import__'s weird semantics.
if globals:
__name__ = globals.get('__name__')
if __name__:
# Maybe do a relative import
if '__path__' not in globals:
# We have an ordinary module, not a package,
# so remove last name segment:
__name__ = '.'.join(__name__.split('.')[:-1])
if __name__:
module = _imp(name, fromlist, __name__ + '.')
if module is not None:
return module
module = _imp(name, fromlist)
if module is not None:
return module
raise ImportError(name)
builtins['__import__'] = ProxyFactory(__import__)
return builtins
def secured_iterator(permission, query, parent):
for item in query:
item.__parent__ = parent
proxied = ProxyFactory(item)
if checkPermission(u"zope.View", proxied):
yield item
def setUp(self):
self.x = Something()
self.c = Checker()
self.p = ProxyFactory(self.x, self.c)
def proxy(self, value):
if type(value) in self.unproxied_types:
return value
return ProxyFactory(value, self)
