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)