Example #1
0
        def as_view(cls, **initkwargs):
            """
            Main entry point for a request-response process.
            """
            # sanitize keyword arguments
            for key in initkwargs:
                if key in cls.http_method_names:
                    raise TypeError(u"You tried to pass in the %s method name as a "
                                    u"keyword argument to %s(). Don't do that."
                                    % (key, cls.__name__))
                if not hasattr(cls, key):
                    raise TypeError(u"%s() received an invalid keyword %r" % (
                        cls.__name__, key))

            def view(request, *args, **kwargs):
                self = cls(**initkwargs)
                return self.dispatch(request, *args, **kwargs)

            # take name and docstring from class
            update_wrapper(view, cls, updated=())

            # and possible attributes set by decorators
            # like csrf_exempt from dispatch
            update_wrapper(view, cls.dispatch, assigned=())
            return view
Example #2
0
def args_method_decorator(decorator, *dargs, **dkwargs):
    """
    Converts a function decorator into a method decorator, with arguments.
    Copied from django.utils.decorators.method_decorator to allow arguments.
    """
    # 'func' is a function at the time it is passed to _dec, but will eventually
    # be a method of the class it is defined it.
    def _dec(func):
        def _wrapper(self, *args, **kwargs):
            @decorator(*dargs, **dkwargs)
            def bound_func(*args2, **kwargs2):
                return func(self, *args2, **kwargs2)
            # bound_func has the signature that 'decorator' expects i.e.  no
            # 'self' argument, but it is a closure over self so it can call
            # 'func' correctly.
            return bound_func(*args, **kwargs)
        # In case 'decorator' adds attributes to the function it decorates, we
        # want to copy those. We don't have access to bound_func in this scope,
        # but we can cheat by using it on a dummy function.
        @decorator(*dargs, **dkwargs)
        def dummy(*args, **kwargs):
            pass
        update_wrapper(_wrapper, dummy)
        # Need to preserve any existing attributes of 'func', including the name.
        update_wrapper(_wrapper, func)

        return _wrapper
    update_wrapper(_dec, decorator)
    # Change the name to aid debugging.
    _dec.__name__ = 'method_decorator(%s)' % decorator.__name__
    return _dec
Example #3
0
        def wrap(view, cacheable=False):
            def wrapper(*args, **kwargs):
                return self.rest_view(view, cacheable)(*args, **kwargs)

            return update_wrapper(wrapper, view)
Example #4
0
        def wrap(view):
            def wrapper(*args, **kwargs):
                return self.admin_site.admin_view(view)(*args, **kwargs)

            return update_wrapper(wrapper, view)
Example #5
0
        def wrap(view):
            # This is needed to secure the view so that only admin users can access
            def wrapper(*args, **kwargs):
                return self.admin_site.admin_view(view)(*args, **kwargs)

            return update_wrapper(wrapper, view)
Example #6
0
 def __init__(self, view):
     self.view = view
     update_wrapper(self, view)
Example #7
0
def store_read(func):
    def wrapper(*args, **kwargs):
        from lib.functions import latinaze
        import re
        spec_lookup = re.compile("^.*\_{2}(i?exact|i?contains|(l|g)te|i?(start|end)swith)$")
        result = func(*args, **kwargs)
        rdata = args[1]
        if isinstance(result, tuple):
            result, extras = result
            success = True
        else:
            success = True
            extras = {}
        total=0
        if isinstance(result, QuerySet) or isinstance(result, QuerySetChain):                        
            if 'filter_fields' in rdata and 'filter_value' in rdata:
                query=None
                if 'query' in rdata:
                    for node in rdata['filter_fields']:
                        val=unicode(rdata['query'])                        
                        wild = val.split('*')                 
                        query2 = None
                        for v in wild:
                            if not v == '':
                                if spec_lookup.match(node):
                                    if query2:                            
                                        query2 = query2 & Q(**{"%s" % str(node):v})
                                    else:
                                        query2 = Q(**{"%s" % str(node):v})
                                else:
                                    if query2:                            
                                        query2 = query2 & Q(**{"%s__icontains" % str(node):v})
                                    else:
                                        query2 = Q(**{"%s__istartswith" % str(node):v})
                        if query:
                            query = query | query2
                        else:
                            query = query2
                if not rdata['filter_value']=='':                    
                    for node in rdata['filter_fields']:
                        if 'passport' in node:
                            val=latinaze(rdata['filter_value'])
                        else:
                            val=unicode(rdata['filter_value'])
                        wild = val.split('*')
                        query2 = None
                        for v in wild:
                            if not v == '':
                                if spec_lookup.match(node):
                                    if query2:
                                        query2 = query2 & Q(**{"%s" % str(node):v})
                                    else:
                                        query2 = Q(**{"%s" % str(node):v})
                                else:
                                    if query2:
                                        query2 = query2 & Q(**{"%s__icontains" % str(node):v})
                                    else:
                                        query2 = Q(**{"%s__icontains" % str(node):v})
                        if query:
                            query = query | query2
                        else:
                            query = query2
                if query:
                    result = result.filter(query)
            if 'filter' in rdata:
                for item in rdata['filter']:
                    val = unicode(rdata['filter'][item])
                    result = result.filter(**{str(item):val})
            if 'sort' in rdata:
                if 'dir' in rdata and rdata['dir']=='DESC':
                    result = result.order_by('-%s' % rdata['sort'])
                else:
                    result = result.order_by('%s' % rdata['sort'])
            total = result.count()
            if 'start' in rdata and 'limit' in rdata:
                result = result[rdata['start']:rdata['start']+rdata['limit']]            
            result = [obj.store_record() for obj in result]
        return dict(data=result, success=success, total=total, extras=extras)
    return update_wrapper(wrapper, func)
Example #8
0
def redis_key_wrapper(func, key):
    def wrapper(*args, **kwargs):
        if IGNORE_REDIS:
            return
        return func(key, *args, **kwargs)
    return update_wrapper(wrapper, func)
Example #9
0
        def wrap(view):
            def wrapper(*args, **kwds):
                kwds['admin'] = self
                return self.admin_site.admin_view(view)(*args, **kwds)

            return update_wrapper(wrapper, view)
Example #10
0
        def wrap(view):
            def wrapper(*args, **kwargs):
                return self.api_view(view, *args, **kwargs)

            return update_wrapper(wrapper, view)
Example #11
0
        def wrap(view):
            def wrapper(*args, **kwargs):
                #kwargs['model_admin'] = self
                return self.admin_site.admin_view(view)(*args, **kwargs)

            return update_wrapper(wrapper, view)
Example #12
0
 def wrap(self, view):
     from django.utils.functional import update_wrapper
     def wrapper(*args, **kwargs):
         return self.admin_site.admin_view(view)(*args, **kwargs)
     return update_wrapper(wrapper, view)