def login_required(func):

     '''

     If you decorate a view with this, it will ensure that the current user is

     logged in and authenticated before calling the actual view. (If they are

     not, it calls the :attr:`LoginManager.unauthorized` callback.) For

     example::

         @app.route('/post')

         @login_required

         def post():

             pass

     If there are only certain times you need to require that your user is

     logged in, you can do so with::

         if not current_user.is_authenticated:

             return current_app.login_manager.unauthorized()

     ...which is essentially the code that this function adds to your views.

     It can be convenient to globally turn off authentication when unit testing.

     To enable this, if the application configuration variable `LOGIN_DISABLED`

     is set to `True`, this decorator will be ignored.

     :param func: The view function to decorate.

     :type func: function

     '''

     @wraps(func)

     def decorated_view(*args, **kwargs):

         if current_app.login_manager._login_disabled:

             return func(*args, **kwargs)

         elif not current_user.is_authenticated:

             return current_app.login_manager.unauthorized()

         return func(*args, **kwargs)

     return decorated_view

    def route(self, rule, **options):

        """A decorator that is used to register a view function for a

        given URL rule.  Example::

            @app.route('/')

            def index():

                return 'Hello World'

        Variables parts in the route can be specified with angular

        brackets (``/user/<username>``).  By default a variable part

        in the URL accepts any string without a slash however a different

        converter can be specified as well by using ``<converter:name>``.

        Variable parts are passed to the view function as keyword

        arguments.

        The following converters are possible:

        =========== ===========================================

        `int`       accepts integers

        `float`     like `int` but for floating point values

        `path`      like the default but also accepts slashes

        =========== ===========================================

        Here some examples::

            @app.route('/')

            def index():

                pass

            @app.route('/<username>')

            def show_user(username):

                pass

            @app.route('/post/<int:post_id>')

            def show_post(post_id):

                pass

        An important detail to keep in mind is how Flask deals with trailing

        slashes.  The idea is to keep each URL unique so the following rules

        apply:

        1. If a rule ends with a slash and is requested without a slash

           by the user, the user is automatically redirected to the same

           page with a trailing slash attached.

        2. If a rule does not end with a trailing slash and the user request

           the page with a trailing slash, a 404 not found is raised.

        This is consistent with how web servers deal with static files.  This

        also makes it possible to use relative link targets safely.

        The :meth:`route` decorator accepts a couple of other arguments

        as well:

        :param rule: the URL rule as string

        :param methods: a list of methods this rule should be limited

                        to (``GET``, ``POST`` etc.).  By default a rule

                        just listens for ``GET`` (and implicitly ``HEAD``).

        :param subdomain: specifies the rule for the subdoain in case

                          subdomain matching is in use.

        :param strict_slashes: can be used to disable the strict slashes

                               setting for this rule.  See above.

        :param options: other options to be forwarded to the underlying

                        :class:`~werkzeug.routing.Rule` object.

        """

        def decorator(f):

            self.add_url_rule(rule, f.__name__, **options)

            self.view_functions[f.__name__] = f

            return f

        return decorator

     def add_url_rule(self, rule, endpoint, **options):

         """Connects a URL rule.  Works exactly like the :meth:`route`

         decorator but does not register the view function for the endpoint.

         Basically this example::

             @app.route('/')

             def index():

                 pass

         Is equivalent to the following::

             def index():

                 pass

             app.add_url_rule('index', '/')

             app.view_functions['index'] = index

         :param rule: the URL rule as string

         :param endpoint: the endpoint for the registered URL rule.  Flask

                          itself assumes the name of the view function as

                          endpoint

         :param options: the options to be forwarded to the underlying

                         :class:`~werkzeug.routing.Rule` object

         """

         options['endpoint'] = endpoint

         options.setdefault('methods', ('GET',))

         self.url_map.add(Rule(rule, **options))

def dispatch_request(self):

    """Does the request dispatching.  Matches the URL and returns the

    return value of the view or error handler.  This does not have to

    be a response object.  In order to convert the return value to a

    proper response object, call :func:`make_response`.

    """

    req = _request_ctx_stack.top.request

    if req.routing_exception is not None:

        self.raise_routing_exception(req)

    rule = req.url_rule

    # dispatch to the handler for that endpoint

    return self.view_functions[rule.endpoint](**req.view_args)