Python TemplateDict._push方法代码示例

# 需要导入模块: from DocumentTemplate.DT_Util import TemplateDict [as 别名]
# 或者: from DocumentTemplate.DT_Util.TemplateDict import _push [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 _push [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 _push [as 别名]
    def test7(self):
        "test7"

        def myCmp(s1, s2):
            return -cmp(s1, s2)

        # Create namespace...
        from DocumentTemplate.DT_Util import TemplateDict

        md = TemplateDict()

        # ... and push out function onto the namespace
        md._push({"myCmp": myCmp})

        assert res7 == SortEx(wordlist, (("weight",), ("key", "myCmp", "desc")), md, mapping=1)

# 需要导入模块: from DocumentTemplate.DT_Util import TemplateDict [as 别名]
# 或者: from DocumentTemplate.DT_Util.TemplateDict import _push [as 别名]
    def test7(self):
        def myCmp(s1, s2):
            if s1 > s2:
                return -1
            if s1 < s2:
                return 1
            return 0

        # Create namespace...
        from DocumentTemplate.DT_Util import TemplateDict
        md = TemplateDict()

        # ... and push out function onto the namespace
        md._push({"myCmp": myCmp})

        self.assertEqual(
            res7,
            SortEx(wordlist, (("weight",), ("key", "myCmp", "desc")), md,
                   mapping=1))

# 需要导入模块: from DocumentTemplate.DT_Util import TemplateDict [as 别名]
# 或者: from DocumentTemplate.DT_Util.TemplateDict import _push [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 _push [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 _push [as 别名]
def exprNamespace(object, workflow, status=None,
                  transition=None, new_state=None, kwargs=None):
    md = TemplateDict()
    if kwargs is None:
        kwargs = {}
    if status is None:
        tool = aq_parent(aq_inner(workflow))
        status = tool.getStatusOf(workflow.id, object)
        if status is None:
            status = {}
    md._push(status)
    md._push(ExprVars(object, workflow))
    d = {'object': object,
         'workflow': workflow,
         'transition': transition,
         'new_state': new_state,
         'kwargs': kwargs,
         }
    md._push(d)
    md._push(workflow.scripts)  # Make scripts automatically available.
    return md

# 需要导入模块: from DocumentTemplate.DT_Util import TemplateDict [as 别名]
# 或者: from DocumentTemplate.DT_Util.TemplateDict import _push [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 _push [as 别名]
def DCWorkflowDefinition_getWorklistVariableMatchDict(self, info,
                                                      check_guard=True):
  """
    Return a dict which has an entry per worklist definition
    (worklist id as key) and which value is a dict composed of
    variable matches.
  """
  if not self.worklists:
    return None

  portal = self.getPortalObject()
  def getPortalTypeListForWorkflow(workflow_id):
      workflow_tool = portal.portal_workflow
      result = []
      append = result.append
      for type_info in workflow_tool._listTypeInfo():
        portal_type = type_info.id
        if workflow_id in workflow_tool.getChainFor(portal_type):
          append(portal_type)
      return result

  _getPortalTypeListForWorkflow = CachingMethod(getPortalTypeListForWorkflow,
                            id='_getPortalTypeListForWorkflow', cache_factory = 'erp5_ui_long')
  portal_type_list = _getPortalTypeListForWorkflow(self.id)
  if not portal_type_list:
    return None
  variable_match_dict = {}
  security_manager = getSecurityManager()
  workflow_id = self.id
  workflow_title = self.title
  for worklist_id, worklist_definition in self.worklists.items():
    action_box_name = worklist_definition.actbox_name
    guard = worklist_definition.guard
    if action_box_name:
      variable_match = {}
      for key in worklist_definition.getVarMatchKeys():
        var = worklist_definition.getVarMatch(key)
        if isinstance(var, Expression):
          evaluated_value = var(createExprContext(StateChangeInfo(portal,
                                self, kwargs=info.__dict__.copy())))
          if isinstance(evaluated_value, (str, int, long)):
            evaluated_value = [str(evaluated_value)]
        else:
          evaluated_value = [x % info for x in var]
        variable_match[key] = evaluated_value
      if 'portal_type' in variable_match and len(variable_match['portal_type']):
        portal_type_intersection = set(variable_match['portal_type'])\
            .intersection(portal_type_list)
        # in case the current workflow is not associated with portal_types
        # defined on the worklist, don't display the worklist for this
        # portal_type.
        variable_match['portal_type'] = list(portal_type_intersection)
      variable_match.setdefault('portal_type', portal_type_list)

      if len(variable_match.get('portal_type', [])) == 0:
        continue
      is_permitted_worklist = 0
      if guard is None:
        is_permitted_worklist = 1
      elif (not check_guard) or \
          Guard_checkWithoutRoles(guard, security_manager, self, portal):
        is_permitted_worklist = 1
        variable_match[SECURITY_PARAMETER_ID] = guard.roles

      if is_permitted_worklist:
        format_data = TemplateDict()
        format_data._push(info)
        variable_match.setdefault(SECURITY_PARAMETER_ID, ())
        format_data._push(dict((k, ('&%s:list=' % k).join(v)) for\
                                           k, v in variable_match.iteritems()))
        variable_match[WORKLIST_METADATA_KEY] = {'format_data': format_data,
                                                 'worklist_title': action_box_name,
                                                 'worklist_id': worklist_id,
                                                 'workflow_title': workflow_title,
                                                 'workflow_id': workflow_id,
                                                 'action_box_url': worklist_definition.actbox_url,
                                                 'action_box_category': worklist_definition.actbox_category}
        variable_match_dict[worklist_id] = variable_match

  if len(variable_match_dict) == 0:
    return None
  return variable_match_dict

# 需要导入模块: from DocumentTemplate.DT_Util import TemplateDict [as 别名]
# 或者: from DocumentTemplate.DT_Util.TemplateDict import _push [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)