Python TemplateDict._pop方法代码示例

# 需要导入模块: from DocumentTemplate.DT_Util import TemplateDict [as 别名]
# 或者: from DocumentTemplate.DT_Util.TemplateDict import _pop [as 别名]
    def render(self, md):
        expr = self.expr
        if isinstance(expr, str):
            v = md[expr]
        else:
            v = expr(md)

        if not self.mapping:
            if isinstance(v, tuple) and len(v) == 1:
                v = v[0]
            v = InstanceDict(v, md)

        if self.only:
            _md = md
            md = TemplateDict()
            if hasattr(_md, 'guarded_getattr'):
                md.guarded_getattr = _md.guarded_getattr
            if hasattr(_md, 'guarded_getitem'):
                md.guarded_getitem = _md.guarded_getitem

        md._push(v)
        try:
            return render_blocks(self.section, md, encoding=self.encoding)
        finally:
            md._pop(1)

# 需要导入模块: from DocumentTemplate.DT_Util import TemplateDict [as 别名]
# 或者: from DocumentTemplate.DT_Util.TemplateDict import _pop [as 别名]
def DCWorkflowDefinition_listObjectActions(self, info):
    '''
    Allows this workflow to
    include actions to be displayed in the actions box.
    Called only when this workflow is applicable to
    info.object.
    Returns the actions to be displayed to the user.
    '''
    fmt_data = None
    ob = info.object
    sdef = self._getWorkflowStateOf(ob)
    if sdef is None:
        return None
    res = []
    for tid in sdef.transitions:
        tdef = self.transitions.get(tid, None)
        if tdef is not None and tdef.trigger_type == TRIGGER_USER_ACTION and \
                tdef.actbox_name and self._checkTransitionGuard(tdef, ob):
            if fmt_data is None:
                fmt_data = TemplateDict()
                fmt_data._push(info)
            fmt_data._push({'transition_id': tid})
            res.append((tid, {
                'id': tid,
                'name': tdef.actbox_name % fmt_data,
                'url': tdef.actbox_url % fmt_data,
                'icon': tdef.actbox_icon % fmt_data,
                'permissions': (),  # Predetermined.
                'category': tdef.actbox_category,
                'transition': tdef}))
            fmt_data._pop()
    res.sort()
    return [ result[1] for result in res ]

# 需要导入模块: from DocumentTemplate.DT_Util import TemplateDict [as 别名]
# 或者: from DocumentTemplate.DT_Util.TemplateDict import _pop [as 别名]
def call_with_ns(f, ns, arg=1):
    td = TemplateDict()
    td.validate = validate
    td.this = ns['here']
    td._push(ns['request'])
    td._push(InstanceDict(td.this, td))
    td._push(ns)
    try:
        if arg==2:
            return f(None, td)
        else:
            return f(td)
    finally:
        td._pop(3)

# 需要导入模块: from DocumentTemplate.DT_Util import TemplateDict [as 别名]
# 或者: from DocumentTemplate.DT_Util.TemplateDict import _pop [as 别名]
 def listGlobalActions(self, info):
     '''
     Allows this workflow to
     include actions to be displayed in the actions box.
     Called on every request.
     Returns the actions to be displayed to the user.
     '''
     if not self.worklists:
         return None  # Optimization
     sm = getSecurityManager()
     portal = self._getPortalRoot()
     res = []
     fmt_data = None
     for id, qdef in self.worklists.items():
         if qdef.actbox_name:
             guard = qdef.guard
             if guard is None or guard.check(sm, self, portal):
                 searchres = None
                 var_match_keys = qdef.getVarMatchKeys()
                 if var_match_keys:
                     # Check the catalog for items in the worklist.
                     catalog = getToolByName(self, 'portal_catalog')
                     dict = {}
                     for k in var_match_keys:
                         v = qdef.getVarMatch(k)
                         v_fmt = map(lambda x, info=info: x%info, v)
                         dict[k] = v_fmt
                     searchres = catalog.searchResults(**dict)
                     if not searchres:
                         continue
                 if fmt_data is None:
                     fmt_data = TemplateDict()
                     fmt_data._push(info)
                 searchres_len = lambda searchres=searchres: len(searchres)
                 fmt_data._push({'count': searchres_len})
                 res.append((id, {'id': id,
                                  'name': qdef.actbox_name % fmt_data,
                                  'url': qdef.actbox_url % fmt_data,
                                  'permissions': (),  # Predetermined.
                                  'category': qdef.actbox_category}))
                 fmt_data._pop()
     res.sort()
     return map((lambda (id, val): val), res)

# 需要导入模块: from DocumentTemplate.DT_Util import TemplateDict [as 别名]
# 或者: from DocumentTemplate.DT_Util.TemplateDict import _pop [as 别名]
 def listGlobalActions(self, info):
     '''
     Allows this workflow to
     include actions to be displayed in the actions box.
     Called on every request.
     Returns the actions to be displayed to the user.
     '''
     if not self.worklists:
         return None  # Optimization
     sm = getSecurityManager()
     portal = self._getPortalRoot()
     res = []
     fmt_data = None
     for id, qdef in self.worklists.items():
         if qdef.actbox_name:
             guard = qdef.guard
             if guard is None or guard.check(sm, self, portal):
                 searchres = None
                 var_match_keys = qdef.getVarMatchKeys()
                 if var_match_keys:
                     # Check the catalog for items in the worklist.
                     catalog = getUtility(ICatalogTool)
                     kw = {}
                     for k in var_match_keys:
                         v = qdef.getVarMatch(k)
                         kw[k] = [ x % info for x in v ]
                     searchres = catalog.searchResults(**kw)
                     if not searchres:
                         continue
                 if fmt_data is None:
                     fmt_data = TemplateDict()
                     fmt_data._push(info)
                 fmt_data._push({'count': len(searchres)})
                 res.append((id, {'id': id,
                                  'name': qdef.actbox_name % fmt_data,
                                  'url': qdef.actbox_url % fmt_data,
                                  'permissions': (),  # Predetermined.
                                  'category': qdef.actbox_category}))
                 fmt_data._pop()
     res.sort()
     return [ result[1] for result in res ]

# 需要导入模块: from DocumentTemplate.DT_Util import TemplateDict [as 别名]
# 或者: from DocumentTemplate.DT_Util.TemplateDict import _pop [as 别名]
 def _listGlobalActions(user=None, id=None, portal_path=None):
   portal = self._getPortalRoot()
   portal_url = portal.portal_url
   portal_url = portal_url()
   sm = getSecurityManager()
   res = []
   fmt_data = None
   # We want to display some actions depending on the current date
   # So, we can now put this kind of expression : <= "%(now)s"
   # May be this patch should be moved to listFilteredActions in the future
   info.now = DateTime()
   for id, qdef in self.worklists.items():
       if qdef.actbox_name:
         guard = qdef.guard
         # Patch for ERP5 by JP Smets in order
         # to take into account the expression of the guard
         # and nothing else - ERP5Workflow definitely needed some day
         if guard is None or Guard_checkWithoutRoles(
                                       guard, sm, self, portal):
           dict = {}
           # Patch for ERP5 by JP Smets in order
           # to implement worklists and search of local roles
           searchres_len = 0
           var_match_keys = qdef.getVarMatchKeys()
           if var_match_keys:
               # Check the catalog for items in the worklist.
               catalog = portal.portal_catalog
               for k in var_match_keys:
                 v = qdef.getVarMatch(k)
                 if isinstance(v, Expression):
                   v_fmt = v(createExprContext(StateChangeInfo(portal,
                             self, kwargs=info.__dict__.copy())))
                 else:
                   v_fmt = map(lambda x, info=info: x%info, v)
                 dict[k] = v_fmt
               # Patch to automatically filter workflists per portal type
               # so that the same state can be used for different
               # worklists and they are not merged
               if not dict.has_key('portal_type'):
                 dict['portal_type'] = portal_type_list
               # Patch for ERP5 by JP Smets in order
               # to implement worklists and search of local roles
               # we do not take into account the guard here
               if guard is not None and guard.roles:
                 dict['local_roles'] = guard.roles
               # Patch to use ZSQLCatalog and get high speed
               # LOG("PatchedDCWorkflowDefinition", 0, dict)
               searchres_len = int(apply(catalog.countResults, (), dict)[0][0])
               if searchres_len == 0:
                 continue
           if fmt_data is None:
               fmt_data = TemplateDict()
               fmt_data._push(info)
           fmt_data._push({'count': searchres_len})
           # Patch for ERP5 by JP Smets in order to
           # filter per portal type more easily (ie. without
           # hardcoding it all)
           fmt_data._push({'portal_type': '&portal_type='.join(dict['portal_type'])})
           # Patch for ERP5 by JP Smets in order
           # to implement worklists and search of local roles
           if dict.has_key('local_roles'):
             fmt_data._push({'local_roles': '&local_roles='.join(dict['local_roles'])})
           else:
             fmt_data._push({'local_roles': ''})
           res.append((id, {'name': qdef.actbox_name % fmt_data,
                           'url': '%s/%s' % (portal_url, qdef.actbox_url % fmt_data),
                           'worklist_id': id,
                           'workflow_title': self.title,
                           'workflow_id': self.id,
                           'permissions': (),  # Predetermined.
                           'category': qdef.actbox_category}))
           fmt_data._pop()
   res.sort()
   return map((lambda (id, val): val), res)

# 需要导入模块: from DocumentTemplate.DT_Util import TemplateDict [as 别名]
# 或者: from DocumentTemplate.DT_Util.TemplateDict import _pop [as 别名]

#.........这里部分代码省略.........
        sources, in the order in which they are consulted, are:

          o  Keyword arguments,

          o  The 'client' argument,

          o  The 'mapping' argument,

          o  The keyword arguments provided when the object was
             created, and

          o  The 'mapping' argument provided when the template was
             created.

        '''
        # print '============================================================'
        # print '__called__'
        # print self.raw
        # print kw
        # print client
        # print mapping
        # print '============================================================'

        if mapping is None: mapping = {}
        if hasattr(mapping, 'taintWrapper'): mapping = mapping.taintWrapper()

        if not hasattr(self,'_v_cooked'):
            try: changed=self.__changed__()
            except: changed=1
            self.cook()
            if not changed: self.__changed__(0)

        pushed=None
        try:
            # Support Python 1.5.2, but work better in 2.1
            if (mapping.__class__ is TemplateDict or
                isinstance(mapping, TemplateDict)): pushed=0
        except: pass

        globals=self.globals
        if pushed is not None:
            # We were passed a TemplateDict, so we must be a sub-template
            md=mapping
            push=md._push
            if globals:
                push(self.globals)
                pushed=pushed+1
        else:
            md=TemplateDict()
            push=md._push
            shared_globals=self.shared_globals
            if shared_globals: push(shared_globals)
            if globals: push(globals)
            if mapping:
                push(mapping)
            md.guarded_getattr=self.guarded_getattr
            md.guarded_getitem=self.guarded_getitem
            if client is not None:
                if type(client)==type(()):
                    md.this=client[-1]
                else: md.this=client
            pushed=0

        level=md.level
        if level > 200: raise SystemError, (
            'infinite recursion in document template')
        md.level=level+1

        if client is not None:
            if type(client)==type(()):
                # if client is a tuple, it represents a "path" of clients
                # which should be pushed onto the md in order.
                for ob in client:
                    push(InstanceDict(ob, md)) # Circ. Ref. 8-|
                    pushed=pushed+1
            else:
                # otherwise its just a normal client object.
                push(InstanceDict(client, md)) # Circ. Ref. 8-|
                pushed=pushed+1

        if self._vars:
            push(self._vars)
            pushed=pushed+1

        if kw:
            push(kw)
            pushed=pushed+1

        try:
            value = self.ZDocumentTemplate_beforeRender(md, _marker)
            if value is _marker:
                try: result = render_blocks(self._v_blocks, md)
                except DTReturn, v: result = v.v
                self.ZDocumentTemplate_afterRender(md, result)
                return result
            else:
                return value
        finally:
            if pushed: md._pop(pushed) # Get rid of circular reference!
            md.level=level # Restore previous level