Make $routeProvider redirectTo injectable

[jr314159]

I would like to add dependency injection support for the redirectTo function, but I can't see a way to implement this without breaking the existing API.

I frequently need services available when determining where to redirect, and as a workaround, I end up defining routes with empty templates purely for handling redirect logic, and calling $location.path() from within a resolve function on that route. It seems messy and would be much nicer to just keep this logic contained inside redirectTo.

Would this be welcome as a PR and if so, any suggestions on implementation so as to avoid breaking existing code that expects normal function parameters on this method?

[worldspawn]

I second this, in my case i needed to inject a service, furthermore i needed to wait for that service to do something (so i needed promises). But after some experimentation I found that this could be achieved with "resolve", at least in my scenario. Calling $location.path() doesn't seem to be much different to what redirectTo does.

eg:

$routeProvider.otherwise({
                resolve: {
                    load: [
                        '$rootScope', '$q', 'authentication', '$location', function ($rootScope, $q, authentication, $location) {
                            var defer = $q.defer();
                            function chooseRoute() {
                                if (authentication.identity === undefined) {
                                    $location.path('/logon');
                                } else {
                                    $location.path('/somewhere');
                                }

                                defer.reject();
                            }

                            if (authentication.identityResolved)
                                chooseRoute();
                            else {
                                var unbind = $rootScope.$watch(function () { return authentication.identityResolved; }, function (resolved) {
                                    if (!resolved)
                                        return;

                                    chooseRoute();
                                    unbind();
                                });
                            }

                            return defer.promise;
                        }
                    ]
                }
            });

[jr314159]

Oh, that's smart. I'd been doing exactly this in other route definitions, I don't know why it never occurred to me to do this in otherwise.

[mrniko]

+1

[luigidt]

+1

[jviotti]

A nicer workaround I came up with:

Add the following run block:

.run([ '$rootScope', '$injector', '$location', ($rootScope, $injector, $location) ->

    $rootScope.$on '$routeChangeStart', (event, next, current) ->
        redirectionFunction = next.$$route?.redirection
        return if not redirectionFunction?
        route = $injector.invoke(redirectionFunction)
        $location.path(route) if route?
])

Then, in your routes, you can use a custom redirection attribute that allows injection:

$routeProvider.when '/login',
    templateUrl: 'login.tpl.html'       
        redirection: [ 'AuthService', (AuthService) ->

            if AuthService.isLoggedIn()
                return '/dashboard'

        ]

[basvanmeurs]

jviotti, great idea. I used your workaround but I think you should change the event to '$routeChangeSuccess' because otherwise 'resolve' functions won't be run. You usually need these resolve functions to run in case of a dynamic redirection (at least, I did need the dependencies to load to be able to make a redirection decision)

[rinatio]

+1

[christian-kocke]

+1

[seangwright]

+1

[syrianadus]

+1 THANKS

[se3000]

+1

[tmgarcia]

+1

[petebacondarwin]

How about we add a new option to the route config called resolveRedirectTo?
This would be an injectable function that could return a promise to a redirection path.