public static void RegisterRoutes(RouteCollection routes) {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            // Redirect From Old Route to New route
            var targetRoute = routes.Map("target", "yo/{id}/{action}", new { controller = "Home" });
            routes.Redirect(r => r.MapRoute("legacy", "foo/{id}/baz/{action}")).To(targetRoute, new { id = "123", action = "index" });
            routes.Redirect(r => r.MapRoute("legacy2", "foo/baz")).To(targetRoute, new { id = "123", action = "index" });

            // Map Delegate
            routes.MapDelegate("map-delegate", "this-is-a-test", rc => rc.HttpContext.Response.Write("Yeah, it's a test"));
            routes.MapDelegate("map-delegate-incoming-only", "this-is-a-test", new { whatever = new IncomingOnlyRouteConstraint() }, rc => rc.HttpContext.Response.Write("Yeah, it's a test"));

            // Map HTTP Handlers
            routes.MapHttpHandler<HelloWorldHttpHandler>("hello-world", "handlers/helloworld");
            routes.MapHttpHandler("hello-world2", "handlers/helloworld2", new HelloWorldHttpHandler());

            RouteCollection someRoutes = new RouteCollection();
            someRoutes.MapHttpHandler<HelloWorldHttpHandler>("hello-world3", "handlers/helloworld3");
            someRoutes.MapHttpHandler("hello-world4", "handlers/helloworld4", new HelloWorldHttpHandler());
            var groupRoute = new GroupRoute("~/section", someRoutes);
            routes.Add("group", groupRoute);

            var mvcRoutes = new RouteCollection();
            mvcRoutes.Map("foo1", "foo/{controller}", new { action = "index" });
            mvcRoutes.Map("foo2", "foo2/{controller}", new { action = "index" });
            routes.Add("group2", new GroupRoute("~/group2sec", mvcRoutes));

            var defaultRoute = routes.Map(
                "Default", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
            ).SetRouteName("Default");
        }
        public void Redirect_WithNullRoutes_ThrowsArgumentNullException()
        {
            // arrange
            RouteCollection routes = null;

            // Act, Assert
            Assert.Throws <ArgumentNullException>(() => routes.Redirect(r => new Mock <RouteBase>().Object));
        }
        public void Redirect_WithNullSourceRouteMapping_ThrowsArgumentNullException()
        {
            // arrange
            var targetRoute = new Mock<RouteBase>().Object;
            RouteCollection routes = new RouteCollection();

            // Act, Assert
            Assert.Throws<ArgumentNullException>(() => routes.Redirect(null));
        }
        public void Redirect_WithNullSourceRouteMapping_ThrowsArgumentNullException()
        {
            // arrange
            var             targetRoute = new Mock <RouteBase>().Object;
            RouteCollection routes      = new RouteCollection();

            // Act, Assert
            Assert.Throws <ArgumentNullException>(() => routes.Redirect(null));
        }
Example #5
0
        /// <summary>
        /// Registers the routes.
        /// </summary>
        /// <param name="routes">The routes.</param>
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
           
            // old routes, permenant redirects
            var homeRoute = routes.MapRoute("Home", "Home", new { controller = "Home", action = "Index", id = UrlParameter.Optional });
            var aboutRoute = routes.MapRoute("About", "About", new { controller = "Home", action = "About", id = UrlParameter.Optional });
            var resumeRoute = routes.MapRoute("Resume", "Resume", new { controller = "Home", action = "Resume", id = UrlParameter.Optional });
            routes.Redirect(r => r.MapRoute("oldHome", "Home"), true).To(homeRoute);
            routes.Redirect(r => r.MapRoute("oldAboutMe", "AboutMe"), true).To(aboutRoute);
            routes.Redirect(r => r.MapRoute("oldAboutSite", "AboutSite"), true).To(aboutRoute);
            routes.Redirect(r => r.MapRoute("oldResume", "Resume"), true).To(resumeRoute);
            routes.Redirect(r => r.MapRoute("oldProjects", "Projects"), true).To(homeRoute);

            routes.MapRoute(
                name: "Default",
                url: "{controller}/{action}/{id}",
                defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional });
        }
        public void Redirect_WithRouteMappingFunc_DoesNotAddRouteToMainRoutes() {
            // Arrange
            var routes = new RouteCollection();
            var targetRoute = new Mock<RouteBase>().Object;

            // Act
            var redirectRoute = routes.Redirect(r => r.Map("test", "testurl")).To(targetRoute);

            // Assert
            PAssert.IsTrue(() => routes.Count == 1);
            PAssert.IsTrue(() => routes[0] is NormalizeRoute);
        }
        public void Redirect_WithRouteMappingFunc_DoesNotAddRouteToMainRoutes()
        {
            // Arrange
            var routes      = new RouteCollection();
            var targetRoute = new Mock <RouteBase>().Object;

            // Act
            var redirectRoute = routes.Redirect(r => r.Map("test", "testurl")).To(targetRoute);

            // Assert
            PAssert.IsTrue(() => routes.Count == 1);
            PAssert.IsTrue(() => routes[0] is NormalizeRoute);
        }
        public void Redirect_SourceRouteButNoTarget_ReturnsPartialRedirectRoute() {
            // Arrange
            var routes = new RouteCollection();
            var sourceRoute = new Mock<RouteBase>().Object;

            // Act
            var redirectRoute = routes.Redirect(r => sourceRoute, permanent: true);

            // Assert
            PAssert.IsTrue(() => redirectRoute.SourceRoute == sourceRoute);
            PAssert.IsTrue(() => redirectRoute.TargetRoute == null);
            PAssert.IsTrue(() => redirectRoute.Permanent == true);
        }
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            //http://haacked.com/archive/2011/02/02/redirecting-routes-to-maintain-persistent-urls.aspx
            var images = routes.MapRoute("content_images", "content/images/{file}");
            routes.Redirect(r => r.MapRoute("moth_images", "resources/images/{file}"))
                .To(images);

            //            routes.MapHttpRoute(
            //                name: "DefaultApi",
            //                routeTemplate: "api/{controller}/{id}",
            //                defaults: new { id = RouteParameter.Optional }
            //            );

            routes.MapRoute(
                name: null,
                url: "login",
                defaults: new { controller = "Account", action = "Login", performanceId = UrlParameter.Optional }
            );

            routes.MapRoute(
                name: null,
                url: "logoff",
                defaults: new { controller = "Account", action = "LogOff", performanceId = UrlParameter.Optional }
            );

            routes.MapRoute(
                name: null,
                url: "summary/{performanceId}",
                defaults: new { controller = "Scoring", action = "Summary", performanceId = UrlParameter.Optional  }
            );

            routes.MapRoute(
                name: null,
                url: "entry/{performanceId}/judges-{judgeId}",
                defaults: new { controller = "Scoring", action = "ScoreEntry" }
            );

            routes.MapRoute(
                name: null,
                url: "performances/{id}",
                defaults: new { controller = "Performance", action = "Index" }
            );

            routes.MapRoute(
                name: "Default",
                url: "{controller}/{action}/{id}",
                defaults: new { controller = "Landing", action = "Index", id = UrlParameter.Optional }
            );
        }
Example #10
0
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            // Redirect From Old Route to New route
            var targetRoute = routes.Map("target", "yo/{id}/{action}", new { controller = "Home" });

            routes.Redirect(r => r.MapRoute("legacy", "foo/{id}/baz/{action}")).To(targetRoute, new { id = "123", action = "index" });
            routes.Redirect(r => r.MapRoute("legacy2", "foo/baz")).To(targetRoute, new { id = "123", action = "index" });

            // Map Delegate
            routes.MapDelegate("map-delegate", "this-is-a-test", rc => rc.HttpContext.Response.Write("Yeah, it's a test"));
            routes.MapDelegate("map-delegate-incoming-only", "this-is-a-test", new { whatever = new IncomingOnlyRouteConstraint() }, rc => rc.HttpContext.Response.Write("Yeah, it's a test"));

            // Map HTTP Handlers
            routes.MapHttpHandler <HelloWorldHttpHandler>("hello-world", "handlers/helloworld");
            routes.MapHttpHandler("hello-world2", "handlers/helloworld2", new HelloWorldHttpHandler());

            RouteCollection someRoutes = new RouteCollection();

            someRoutes.MapHttpHandler <HelloWorldHttpHandler>("hello-world3", "handlers/helloworld3");
            someRoutes.MapHttpHandler("hello-world4", "handlers/helloworld4", new HelloWorldHttpHandler());
            var groupRoute = new GroupRoute("~/section", someRoutes);

            routes.Add("group", groupRoute);

            var mvcRoutes = new RouteCollection();

            mvcRoutes.Map("foo1", "foo/{controller}", new { action = "index" });
            mvcRoutes.Map("foo2", "foo2/{controller}", new { action = "index" });
            routes.Add("group2", new GroupRoute("~/group2sec", mvcRoutes));

            var defaultRoute = routes.Map(
                "Default",                    // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new { controller = "Home", action = "Index", id = UrlParameter.Optional } // Parameter defaults
                ).SetRouteName("Default");
        }
        public void Redirect_SourceAndTarget_ReturnsRedirectRoute() {
            // Arrange
            var routes = new RouteCollection();
            var sourceRoute = new Mock<RouteBase>().Object;
            var targetRoute = new Mock<RouteBase>().Object;

            // Act
            var redirectRoute = routes.Redirect(r => sourceRoute, permanent: false).To(targetRoute);

            // Assert
            PAssert.IsTrue(() => redirectRoute.SourceRoute == sourceRoute);
            PAssert.IsTrue(() => redirectRoute.TargetRoute == targetRoute);
            PAssert.IsTrue(() => redirectRoute.Permanent == false);
        }
        public void Redirect_SourceRouteButNoTarget_ReturnsPartialRedirectRoute()
        {
            // Arrange
            var routes      = new RouteCollection();
            var sourceRoute = new Mock <RouteBase>().Object;

            // Act
            var redirectRoute = routes.Redirect(r => sourceRoute, permanent: true);

            // Assert
            PAssert.IsTrue(() => redirectRoute.SourceRoute == sourceRoute);
            PAssert.IsTrue(() => redirectRoute.TargetRoute == null);
            PAssert.IsTrue(() => redirectRoute.Permanent == true);
        }
        public void Redirect_SourceAndTarget_ReturnsRedirectRoute()
        {
            // Arrange
            var routes      = new RouteCollection();
            var sourceRoute = new Mock <RouteBase>().Object;
            var targetRoute = new Mock <RouteBase>().Object;

            // Act
            var redirectRoute = routes.Redirect(r => sourceRoute, permanent: false).To(targetRoute);

            // Assert
            PAssert.IsTrue(() => redirectRoute.SourceRoute == sourceRoute);
            PAssert.IsTrue(() => redirectRoute.TargetRoute == targetRoute);
            PAssert.IsTrue(() => redirectRoute.Permanent == false);
        }
Example #14
0
        public static void RegisterUIRoutes(RouteCollection routes)
        {
            routes.MapRoute(
                RouteName.Home,
                "",
                new { controller = "Pages", action = "Home" }); // T4MVC doesn't work with Async Action

            routes.MapRoute(
                RouteName.ErrorReadOnly,
                "errors/readonly",
                new { controller = "Errors", action = "ReadOnlyMode" });

            routes.MapRoute(
                RouteName.Error500,
                "errors/500",
                new { controller = "Errors", action = "InternalError" });

            routes.MapRoute(
                RouteName.Error404,
                "errors/404",
                new { controller = "Errors", action = "NotFound" });

            routes.MapRoute(
                RouteName.Error400,
                "errors/400",
                new { controller = "Errors", action = "BadRequest" });

            routes.MapRoute(
                RouteName.StatisticsHome,
                "stats",
                new { controller = "Statistics", action = "Index" });

            routes.MapRoute(
                RouteName.Stats,
                "stats/totals",
                new { controller = "Statistics", action = "Totals" });

            routes.MapRoute(
                RouteName.StatisticsPackages,
                "stats/packages",
                new { controller = "Statistics", action = "Packages" });

            routes.MapRoute(
                RouteName.StatisticsPackageVersions,
                "stats/packageversions",
                new { controller = "Statistics", action = "PackageVersions" });

            routes.MapRoute(
                RouteName.StatisticsPackageDownloadsDetail,
                "stats/packages/{id}/{version}",
                new { controller = "Statistics", action = "PackageDownloadsDetail" });

            routes.MapRoute(
                RouteName.StatisticsPackageDownloadsDetailReport,
                "stats/reports/packages/{id}/{version}",
                new { controller = "Statistics", action = "PackageDownloadsDetailReport" });

            routes.MapRoute(
                RouteName.StatisticsPackageDownloadsByVersion,
                "stats/packages/{id}",
                new { controller = "Statistics", action = "PackageDownloadsByVersion" });

            routes.MapRoute(
                RouteName.StatisticsPackageDownloadsByVersionReport,
                "stats/reports/packages/{id}",
                new { controller = "Statistics", action = "PackageDownloadsByVersionReport" });

            routes.MapRoute(
                RouteName.JsonApi,
                "json/{action}",
                new { controller = "JsonApi" });

            routes.MapRoute(
                RouteName.Contributors,
                "pages/contributors",
                new { controller = "Pages", action = "Contributors" });

            routes.MapRoute(
                RouteName.Policies,
                "policies/{action}",
                new { controller = "Pages" });

            routes.MapRoute(
                RouteName.Pages,
                "pages/{pageName}",
                new { controller = "Pages", action = "Page" });

            var packageListRoute = routes.MapRoute(
                RouteName.ListPackages,
                "packages",
                new { controller = "Packages", action = "ListPackages" });

            var uploadPackageRoute = routes.MapRoute(
                RouteName.UploadPackage,
                "packages/manage/upload",
                new { controller = "Packages", action = "UploadPackage" });

            routes.MapRoute(
                RouteName.UploadPackageProgress,
                "packages/manage/upload-progress",
                new { controller = "Packages", action = "UploadPackageProgress" });

            routes.MapRoute(
                RouteName.VerifyPackage,
                "packages/manage/verify-upload",
                new { controller = "Packages", action = "VerifyPackage" });

            routes.MapRoute(
                RouteName.PreviewReadMe,
                "packages/manage/preview-readme",
                new { controller = "Packages", action = "PreviewReadMe" });

            routes.MapRoute(
                RouteName.CancelUpload,
                "packages/manage/cancel-upload",
                new { controller = "Packages", action = "CancelUpload" });

            routes.MapRoute(
                RouteName.PackageOwnerConfirmation,
                "packages/{id}/owners/{username}/confirm/{token}",
                new { controller = "Packages", action = "ConfirmPendingOwnershipRequest" });

            routes.MapRoute(
                RouteName.PackageOwnerRejection,
                "packages/{id}/owners/{username}/reject/{token}",
                new { controller = "Packages", action = "RejectPendingOwnershipRequest" });

            routes.MapRoute(
                RouteName.PackageOwnerCancellation,
                "packages/{id}/owners/{username}/cancel/{token}",
                new { controller = "Packages", action = "CancelPendingOwnershipRequest" });

            // We need the following two routes (rather than just one) due to Routing's
            // Consecutive Optional Parameter bug. :(
            var packageDisplayRoute = routes.MapRoute(
                RouteName.DisplayPackage,
                "packages/{id}/{version}",
                new
            {
                controller = "packages",
                action     = "DisplayPackage",
                version    = UrlParameter.Optional
            },
                new { version = new VersionRouteConstraint() });

            routes.MapRoute(
                RouteName.PackageEnableLicenseReport,
                "packages/{id}/{version}/EnableLicenseReport",
                new { controller = "Packages", action = "SetLicenseReportVisibility", visible = true },
                new { version = new VersionRouteConstraint() });

            routes.MapRoute(
                RouteName.PackageDisableLicenseReport,
                "packages/{id}/{version}/DisableLicenseReport",
                new { controller = "Packages", action = "SetLicenseReportVisibility", visible = false },
                new { version = new VersionRouteConstraint() });

            var packageVersionActionRoute = routes.MapRoute(
                RouteName.PackageVersionAction,
                "packages/{id}/{version}/{action}",
                new { controller = "Packages" },
                new { version = new VersionRouteConstraint() });

            var packageActionRoute = routes.MapRoute(
                RouteName.PackageAction,
                "packages/{id}/{action}",
                new { controller = "Packages" });

            var confirmationRequiredRoute = routes.MapRoute(
                "ConfirmationRequired",
                "account/ConfirmationRequired",
                new { controller = "Users", action = "ConfirmationRequired" });

            //Redirecting v1 Confirmation Route
            routes.Redirect(
                r => r.MapRoute(
                    "v1Confirmation",
                    "Users/Account/ChallengeEmail")).To(confirmationRequiredRoute);

            routes.MapRoute(
                RouteName.ExternalAuthenticationCallback,
                "users/account/authenticate/return",
                new { controller = "Authentication", action = "LinkExternalAccount" });

            routes.MapRoute(
                RouteName.ExternalAuthentication,
                "users/account/authenticate/{provider}",
                new { controller = "Authentication", action = "Authenticate" });

            routes.MapRoute(
                "RegisterAccount",
                "account/register",
                new { controller = "Authentication", action = "Register" },
                new { httpMethod = new HttpMethodConstraint("POST") });

            routes.MapRoute(
                RouteName.LegacyRegister,
                "account/register",
                new { controller = "Authentication", action = "RegisterLegacy" },
                new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                RouteName.LegacyRegister2,
                "users/account/register",
                new { controller = "Authentication", action = "RegisterLegacy" },
                new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                RouteName.Authentication,
                "users/account/{action}",
                new { controller = "Authentication" });

            routes.MapRoute(
                RouteName.Profile,
                "profiles/{username}",
                new { controller = "Users", action = "Profiles" });

            routes.MapRoute(
                RouteName.RemovePassword,
                "account/RemoveCredential/password",
                new { controller = "Users", action = "RemovePassword" });

            routes.MapRoute(
                RouteName.RemoveCredential,
                "account/RemoveCredential/{credentialType}",
                new { controller = "Users", action = "RemoveCredential" });

            routes.MapRoute(
                RouteName.PasswordReset,
                "account/forgotpassword/{username}/{token}",
                new { controller = "Users", action = "ResetPassword", forgot = true });

            routes.MapRoute(
                RouteName.PasswordSet,
                "account/setpassword/{username}/{token}",
                new { controller = "Users", action = "ResetPassword", forgot = false });

            routes.MapRoute(
                RouteName.ConfirmAccount,
                "account/confirm/{username}/{token}",
                new { controller = "Users", action = "Confirm" });

            routes.MapRoute(
                RouteName.ChangeEmailSubscription,
                "account/subscription/change",
                new { controller = "Users", action = "ChangeEmailSubscription" });

            routes.MapRoute(
                RouteName.AdminDeleteAccount,
                "account/delete/{accountName}",
                new { controller = "Users", action = "Delete" });

            routes.MapRoute(
                RouteName.UserDeleteAccount,
                "account/delete",
                new { controller = "Users", action = "DeleteRequest" });

            routes.MapRoute(
                RouteName.Account,
                "account/{action}",
                new { controller = "Users", action = "Account" });

            routes.MapRoute(
                RouteName.ApiKeys,
                "account/apikeys",
                new { controller = "Users", action = "ApiKeys" });

            routes.MapRoute(
                RouteName.CuratedFeed,
                "curated-feeds/{name}",
                new { controller = "CuratedFeeds", action = "CuratedFeed" });

            routes.MapRoute(
                RouteName.CuratedFeedListPackages,
                "curated-feeds/{curatedFeedName}/packages",
                new { controller = "CuratedFeeds", action = "ListPackages" });

            routes.MapRoute(
                RouteName.CreateCuratedPackageForm,
                "forms/add-package-to-curated-feed",
                new { controller = "CuratedPackages", action = "CreateCuratedPackageForm" });

            routes.MapRoute(
                RouteName.CuratedPackage,
                "curated-feeds/{curatedFeedName}/curated-packages/{curatedPackageId}",
                new { controller = "CuratedPackages", action = "CuratedPackage" });

            routes.MapRoute(
                RouteName.CuratedPackages,
                "curated-feeds/{curatedFeedName}/curated-packages",
                new { controller = "CuratedPackages", action = "CuratedPackages" });

            routes.MapRoute(
                RouteName.Downloads,
                "downloads",
                new { controller = "Pages", action = "Downloads" });

            // TODO : Most of the routes are essentially of the format api/v{x}/*. We should refactor the code to vary them by the version.
            // V1 Routes
            // If the push url is /api/v1 then NuGet.Core would ping the path to resolve redirection.
            routes.MapRoute(
                "v1" + RouteName.VerifyPackageKey,
                "api/v1/verifykey/{id}/{version}",
                new
            {
                controller = "Api",
                action     = "VerifyPackageKey",
                version    = UrlParameter.Optional
            });

            routes.MapRoute(
                "v1" + RouteName.CreatePackageVerificationKey,
                "api/v1/package/create-verification-key/{id}/{version}",
                new
            {
                controller = "Api",
                action     = "CreatePackageVerificationKey",
                version    = UrlParameter.Optional
            });

            var downloadRoute = routes.MapRoute(
                "v1" + RouteName.DownloadPackage,
                "api/v1/package/{id}/{version}",
                defaults: new
            {
                controller = "Api",
                action     = "GetPackageApi",
                version    = UrlParameter.Optional
            },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                "v1" + RouteName.PushPackageApi,
                "v1/PackageFiles/{apiKey}/nupkg",
                defaults: new { controller = "Api", action = "PushPackageApi" },
                constraints: new { httpMethod = new HttpMethodConstraint("POST") });

            routes.MapRoute(
                "v1" + RouteName.DeletePackageApi,
                "v1/Packages/{apiKey}/{id}/{version}",
                new { controller = "Api", action = "DeletePackages" });

            routes.MapRoute(
                "v1" + RouteName.PublishPackageApi,
                "v1/PublishedPackages/Publish",
                new { controller = "Api", action = "PublishPackage" });

            // Redirected Legacy Routes

            routes.Redirect(
                r => r.MapRoute(
                    "ReportAbuse",
                    "Package/ReportAbuse/{id}/{version}",
                    new { controller = "Packages", action = "ReportAbuse" }),
                permanent: true).To(packageVersionActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "PackageActions",
                    "Package/{action}/{id}",
                    new { controller = "Packages", action = "ContactOwners" },
                    // This next bit looks bad, but it's not. It will never change because
                    // it's mapping the legacy routes to the new better routes.
                    new { action = "ContactOwners|ManagePackageOwners" }),
                permanent: true).To(packageActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.ListPackages,
                    "List/Packages",
                    new { controller = "Packages", action = "ListPackages" }),
                permanent: true).To(packageListRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.DisplayPackage,
                    "List/Packages/{id}/{version}",
                    new { controller = "Packages", action = "DisplayPackage", version = UrlParameter.Optional }),
                permanent: true).To(packageDisplayRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.NewSubmission,
                    "Contribute/NewSubmission",
                    new { controller = "Packages", action = "UploadPackage" }),
                permanent: true).To(uploadPackageRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "LegacyDownloadRoute",
                    "v1/Package/Download/{id}/{version}",
                    new { controller = "Api", action = "GetPackageApi", version = UrlParameter.Optional }),
                permanent: true).To(downloadRoute);
        }
Example #15
0
        public static void RegisterUIRoutes(RouteCollection routes)
        {
            routes.MapRoute(
                RouteName.Home,
                "",
                new { controller = "Pages", action = "Home" }); // T4MVC doesn't work with Async Action

            routes.MapRoute(
                RouteName.ErrorReadOnly,
                "errors/readonly",
                new { controller = "Errors", action = "ReadOnlyMode" });

            routes.MapRoute(
                RouteName.Error500,
                "errors/500",
                new { controller = "Errors", action = "InternalError" });

            routes.MapRoute(
                RouteName.Error404,
                "errors/404",
                new { controller = "Errors", action = "NotFound" });

            routes.MapRoute(
                RouteName.Error400,
                "errors/400",
                new { controller = "Errors", action = "BadRequest" });

            routes.MapRoute(
                RouteName.StatisticsHome,
                "stats",
                new { controller = "Statistics", action = "Index" });

            routes.MapRoute(
                RouteName.Stats,
                "stats/totals",
                new { controller = "Statistics", action = "Totals" });

            routes.MapRoute(
                RouteName.StatisticsPackages,
                "stats/packages",
                new { controller = "Statistics", action = "Packages" });

            routes.MapRoute(
                RouteName.StatisticsPackageVersions,
                "stats/packageversions",
                new { controller = "Statistics", action = "PackageVersions" });

            routes.MapRoute(
                RouteName.StatisticsPackageDownloadsDetail,
                "stats/packages/{id}/{version}",
                new { controller = "Statistics", action = "PackageDownloadsDetail" });

            routes.MapRoute(
                RouteName.StatisticsPackageDownloadsDetailReport,
                "stats/reports/packages/{id}/{version}",
                new { controller = "Statistics", action = "PackageDownloadsDetailReport" });

            routes.MapRoute(
                RouteName.StatisticsPackageDownloadsByVersion,
                "stats/packages/{id}",
                new { controller = "Statistics", action = "PackageDownloadsByVersion" });

            routes.MapRoute(
                RouteName.StatisticsPackageDownloadsByVersionReport,
                "stats/reports/packages/{id}",
                new { controller = "Statistics", action = "PackageDownloadsByVersionReport" });

            routes.MapRoute(
                RouteName.JsonApi,
                "json/{action}",
                new { controller = "JsonApi" });

            routes.MapRoute(
                RouteName.ManageDeprecationJsonApi,
                "json/deprecation/{action}",
                new { controller = "ManageDeprecationJsonApi" });

            routes.MapRoute(
                RouteName.Contributors,
                "pages/contributors",
                new { controller = "Pages", action = "Contributors" });

            routes.MapRoute(
                RouteName.PagesSimulateError,
                "pages/simulate-error",
                new { controller = "Pages", action = nameof(PagesController.SimulateError) });

            routes.MapRoute(
                RouteName.Policies,
                "policies/{action}",
                new { controller = "Pages" });

            routes.MapRoute(
                RouteName.Pages,
                "pages/{pageName}",
                new { controller = "Pages", action = "Page" });

            var packageListRoute = routes.MapRoute(
                RouteName.ListPackages,
                "packages",
                new { controller = "Packages", action = "ListPackages" });

            var uploadPackageRoute = routes.MapRoute(
                RouteName.UploadPackage,
                "packages/manage/upload",
                new { controller = "Packages", action = "UploadPackage" });

            routes.MapRoute(
                RouteName.UploadPackageProgress,
                "packages/manage/upload-progress",
                new { controller = "Packages", action = "UploadPackageProgress" });

            routes.MapRoute(
                RouteName.VerifyPackage,
                "packages/manage/verify-upload",
                new { controller = "Packages", action = "VerifyPackage" });

            routes.MapRoute(
                RouteName.PreviewReadMe,
                "packages/manage/preview-readme",
                new { controller = "Packages", action = "PreviewReadMe" });

            routes.MapRoute(
                RouteName.CancelUpload,
                "packages/manage/cancel-upload",
                new { controller = "Packages", action = "CancelUpload" });

            routes.MapRoute(
                RouteName.SetRequiredSigner,
                "packages/{id}/required-signer/{username}",
                new { controller = "Packages", action = RouteName.SetRequiredSigner, username = UrlParameter.Optional },
                constraints: new { httpMethod = new HttpMethodConstraint("POST") },
                obfuscationMetadata: new RouteExtensions.ObfuscatedPathMetadata(3, Obfuscator.DefaultTelemetryUserName));

            routes.MapRoute(
                RouteName.PackageOwnerConfirmation,
                "packages/{id}/owners/{username}/confirm/{token}",
                new { controller = "Packages", action = "ConfirmPendingOwnershipRequest" },
                new[]
            {
                new RouteExtensions.ObfuscatedPathMetadata(3, Obfuscator.DefaultTelemetryUserName),
                new RouteExtensions.ObfuscatedPathMetadata(5, Obfuscator.DefaultTelemetryToken)
            });

            routes.MapRoute(
                RouteName.PackageOwnerRejection,
                "packages/{id}/owners/{username}/reject/{token}",
                new { controller = "Packages", action = "RejectPendingOwnershipRequest" },
                new[]
            {
                new RouteExtensions.ObfuscatedPathMetadata(3, Obfuscator.DefaultTelemetryUserName),
                new RouteExtensions.ObfuscatedPathMetadata(5, Obfuscator.DefaultTelemetryToken)
            });

            routes.MapRoute(
                RouteName.PackageOwnerCancellation,
                "packages/{id}/owners/{username}/cancel/{token}",
                new { controller = "Packages", action = "CancelPendingOwnershipRequest" },
                new[]
            {
                new RouteExtensions.ObfuscatedPathMetadata(3, Obfuscator.DefaultTelemetryUserName),
                new RouteExtensions.ObfuscatedPathMetadata(5, Obfuscator.DefaultTelemetryToken)
            });

            // We need the following two routes (rather than just one) due to Routing's
            // Consecutive Optional Parameter bug. :(
            var packageDisplayRoute = routes.MapRoute(
                RouteName.DisplayPackage,
                "packages/{id}/{version}",
                new
            {
                controller = "packages",
                action     = "DisplayPackage",
                version    = UrlParameter.Optional
            },
                new { version = new VersionRouteConstraint() });

            routes.MapRoute(
                RouteName.DisplayPackageFeed,
                "packages/{id}/atom.xml",
                new
            {
                controller = "Packages",
                action     = nameof(PackagesController.AtomFeed)
            });

            routes.MapRoute(
                RouteName.PackageEnableLicenseReport,
                "packages/{id}/{version}/EnableLicenseReport",
                new { controller = "Packages", action = "SetLicenseReportVisibility", visible = true },
                new { version = new VersionRouteConstraint() });

            routes.MapRoute(
                RouteName.PackageDisableLicenseReport,
                "packages/{id}/{version}/DisableLicenseReport",
                new { controller = "Packages", action = "SetLicenseReportVisibility", visible = false },
                new { version = new VersionRouteConstraint() });

            var packageVersionActionRoute = routes.MapRoute(
                RouteName.PackageVersionAction,
                "packages/{id}/{version}/{action}",
                new { controller = "Packages" },
                new { version = new VersionRouteConstraint() });

            var packageActionRoute = routes.MapRoute(
                RouteName.PackageAction,
                "packages/{id}/{action}",
                new { controller = "Packages" });

            var packageDeleteRoute = routes.MapRoute(
                RouteName.PackageDeleteAction,
                "packages/manage/delete",
                new { controller = "Packages", action = "Delete" });

            var confirmationRequiredRoute = routes.MapRoute(
                "ConfirmationRequired",
                "account/ConfirmationRequired",
                new { controller = "Users", action = "ConfirmationRequired" });

            routes.MapRoute(
                RouteName.License,
                "packages/{id}/{version}/license",
                new { controller = "Packages", action = "License" });

            //Redirecting v1 Confirmation Route
            routes.Redirect(
                r => r.MapRoute(
                    "v1Confirmation",
                    "Users/Account/ChallengeEmail")).To(confirmationRequiredRoute);

            routes.MapRoute(
                RouteName.ExternalAuthenticationCallback,
                "users/account/authenticate/return",
                new { controller = "Authentication", action = "LinkExternalAccount" });

            routes.MapRoute(
                RouteName.ExternalAuthentication,
                "users/account/authenticate/{provider}",
                new { controller = "Authentication", action = "Authenticate" });

            routes.MapRoute(
                "RegisterAccount",
                "account/register",
                new { controller = "Authentication", action = "Register" },
                new { httpMethod = new HttpMethodConstraint("POST") });

            routes.MapRoute(
                RouteName.SigninAssistance,
                "account/assistance",
                new { controller = "Authentication", action = "SignInAssistance" },
                new { httpMethod = new HttpMethodConstraint("POST") });

            routes.MapRoute(
                RouteName.LegacyRegister,
                "account/register",
                new { controller = "Authentication", action = "RegisterLegacy" },
                new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                RouteName.LegacyRegister2,
                "users/account/register",
                new { controller = "Authentication", action = "RegisterLegacy" },
                new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                RouteName.Authentication,
                "users/account/{action}",
                new { controller = "Authentication" });

            routes.MapRoute(
                RouteName.Profile,
                "profiles/{username}",
                new { controller = "Users", action = "Profiles" },
                new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName));

            routes.MapRoute(
                RouteName.GetUserCertificate,
                "account/certificates/{thumbprint}",
                new { controller = "Users", action = "GetCertificate" },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                RouteName.DeleteUserCertificate,
                "account/certificates/{thumbprint}",
                new { controller = "Users", action = "DeleteCertificate" },
                constraints: new { httpMethod = new HttpMethodConstraint("DELETE") });

            routes.MapRoute(
                RouteName.GetUserCertificates,
                "account/certificates",
                new { controller = "Users", action = "GetCertificates" },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                RouteName.AddUserCertificate,
                "account/certificates",
                new { controller = "Users", action = "AddCertificate" },
                constraints: new { httpMethod = new HttpMethodConstraint("POST") });

            routes.MapRoute(
                RouteName.RemovePassword,
                "account/RemoveCredential/password",
                new { controller = "Users", action = "RemovePassword" });

            routes.MapRoute(
                RouteName.RemoveCredential,
                "account/RemoveCredential/{credentialType}",
                new { controller = "Users", action = "RemoveCredential" });

            routes.MapRoute(
                RouteName.PasswordReset,
                "account/forgotpassword/{username}/{token}",
                new { controller = "Users", action = "ResetPassword", forgot = true },
                new[]
            {
                new RouteExtensions.ObfuscatedPathMetadata(2, Obfuscator.DefaultTelemetryUserName),
                new RouteExtensions.ObfuscatedPathMetadata(3, Obfuscator.DefaultTelemetryToken)
            });

            routes.MapRoute(
                RouteName.PasswordSet,
                "account/setpassword/{username}/{token}",
                new { controller = "Users", action = "ResetPassword", forgot = false },
                new[]
            {
                new RouteExtensions.ObfuscatedPathMetadata(2, Obfuscator.DefaultTelemetryUserName),
                new RouteExtensions.ObfuscatedPathMetadata(3, Obfuscator.DefaultTelemetryToken)
            });

            routes.MapRoute(
                RouteName.ConfirmAccount,
                "account/confirm/{accountName}/{token}",
                new { controller = "Users", action = "Confirm" },
                new[]
            {
                new RouteExtensions.ObfuscatedPathMetadata(2, Obfuscator.DefaultTelemetryUserName),
                new RouteExtensions.ObfuscatedPathMetadata(3, Obfuscator.DefaultTelemetryToken)
            });

            routes.MapRoute(
                RouteName.ChangeEmailSubscription,
                "account/subscription/change",
                new { controller = "Users", action = "ChangeEmailSubscription" });

            routes.MapRoute(
                RouteName.ChangeMultiFactorAuthentication,
                "account/changeMultiFactorAuthentication",
                new { controller = "Users", action = "ChangeMultiFactorAuthentication" });

            routes.MapRoute(
                RouteName.AdminDeleteAccount,
                "account/delete/{accountName}",
                new { controller = "Users", action = "Delete" },
                new RouteExtensions.ObfuscatedPathMetadata(2, Obfuscator.DefaultTelemetryUserName));

            routes.MapRoute(
                RouteName.UserDeleteAccount,
                "account/delete",
                new { controller = "Users", action = "DeleteRequest" });

            routes.MapRoute(
                RouteName.TransformToOrganization,
                "account/transform",
                new { controller = "Users", action = RouteName.TransformToOrganization });

            routes.MapRoute(
                RouteName.TransformToOrganizationConfirmation,
                "account/transform/confirm/{accountNameToTransform}/{token}",
                new { controller = "Users", action = RouteName.TransformToOrganizationConfirmation },
                new[]
            {
                new RouteExtensions.ObfuscatedPathMetadata(3, Obfuscator.DefaultTelemetryUserName),
                new RouteExtensions.ObfuscatedPathMetadata(4, Obfuscator.DefaultTelemetryToken)
            });

            routes.MapRoute(
                RouteName.TransformToOrganizationRejection,
                "account/transform/reject/{accountNameToTransform}/{token}",
                new { controller = "Users", action = RouteName.TransformToOrganizationRejection },
                new[]
            {
                new RouteExtensions.ObfuscatedPathMetadata(3, Obfuscator.DefaultTelemetryUserName),
                new RouteExtensions.ObfuscatedPathMetadata(4, Obfuscator.DefaultTelemetryToken)
            });

            routes.MapRoute(
                RouteName.TransformToOrganizationCancellation,
                "account/transform/cancel/{token}",
                new { controller = "Users", action = RouteName.TransformToOrganizationCancellation },
                new RouteExtensions.ObfuscatedPathMetadata(3, Obfuscator.DefaultTelemetryToken));

            routes.MapRoute(
                RouteName.ApiKeys,
                "account/apikeys",
                new { controller = "Users", action = "ApiKeys" });

            routes.MapRoute(
                RouteName.Account,
                "account/{action}",
                new { controller = "Users", action = "Account" });

            routes.MapRoute(
                RouteName.AddOrganization,
                "organization/add",
                new { controller = "Organizations", action = "Add" });

            routes.MapRoute(
                RouteName.GetOrganizationCertificate,
                "organization/{accountName}/certificates/{thumbprint}",
                new { controller = "Organizations", action = "GetCertificate" },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") },
                obfuscationMetadata: new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName));

            routes.MapRoute(
                RouteName.DeleteOrganizationCertificate,
                "organization/{accountName}/certificates/{thumbprint}",
                new { controller = "Organizations", action = "DeleteCertificate" },
                constraints: new { httpMethod = new HttpMethodConstraint("DELETE") },
                obfuscationMetadata: new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName));

            routes.MapRoute(
                RouteName.GetOrganizationCertificates,
                "organization/{accountName}/certificates",
                new { controller = "Organizations", action = "GetCertificates" },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") },
                obfuscationMetadata: new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName));

            routes.MapRoute(
                RouteName.AddOrganizationCertificate,
                "organization/{accountName}/certificates",
                new { controller = "Organizations", action = "AddCertificate" },
                constraints: new { httpMethod = new HttpMethodConstraint("POST") },
                obfuscationMetadata: new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName));

            routes.MapRoute(
                RouteName.OrganizationMemberAddAjax,
                "organization/{accountName}/members/add",
                new { controller = "Organizations", action = RouteName.OrganizationMemberAddAjax },
                new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName));

            routes.MapRoute(
                RouteName.OrganizationMemberAdd,
                "organization/{accountName}/members/add/{memberName}/{isAdmin}",
                new { controller = "Organizations", action = RouteName.OrganizationMemberAddAjax },
                new[]
            {
                new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName),
                new RouteExtensions.ObfuscatedPathMetadata(4, Obfuscator.DefaultTelemetryUserName)
            });

            routes.MapRoute(
                RouteName.OrganizationMemberConfirm,
                "organization/{accountName}/members/confirm/{confirmationToken}",
                new { controller = "Organizations", action = RouteName.OrganizationMemberConfirm },
                new[]
            {
                new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName),
                new RouteExtensions.ObfuscatedPathMetadata(4, Obfuscator.DefaultTelemetryToken)
            });

            routes.MapRoute(
                RouteName.OrganizationMemberReject,
                "organization/{accountName}/members/reject/{confirmationToken}",
                new { controller = "Organizations", action = RouteName.OrganizationMemberReject },
                new[]
            {
                new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName),
                new RouteExtensions.ObfuscatedPathMetadata(4, Obfuscator.DefaultTelemetryToken)
            });

            routes.MapRoute(
                RouteName.OrganizationMemberCancelAjax,
                "organization/{accountName}/members/cancel",
                new { controller = "Organizations", action = RouteName.OrganizationMemberCancelAjax },
                new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName));

            routes.MapRoute(
                RouteName.OrganizationMemberCancel,
                "organization/{accountName}/members/cancel/{memberName}",
                new { controller = "Organizations", action = RouteName.OrganizationMemberCancelAjax },
                new[]
            {
                new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName),
                new RouteExtensions.ObfuscatedPathMetadata(4, Obfuscator.DefaultTelemetryUserName)
            });

            routes.MapRoute(
                RouteName.OrganizationMemberUpdateAjax,
                "organization/{accountName}/members/update",
                new { controller = "Organizations", action = RouteName.OrganizationMemberUpdateAjax },
                new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName));

            routes.MapRoute(
                RouteName.OrganizationMemberUpdate,
                "organization/{accountName}/members/update/{memberName}/{isAdmin}",
                new { controller = "Organizations", action = RouteName.OrganizationMemberUpdateAjax },
                new[]
            {
                new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName),
                new RouteExtensions.ObfuscatedPathMetadata(4, Obfuscator.DefaultTelemetryUserName)
            });

            routes.MapRoute(
                RouteName.OrganizationMemberDeleteAjax,
                "organization/{accountName}/members/delete",
                new { controller = "Organizations", action = RouteName.OrganizationMemberDeleteAjax },
                new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName));

            routes.MapRoute(
                RouteName.OrganizationMemberDelete,
                "organization/{accountName}/members/delete/{memberName}",
                new { controller = "Organizations", action = RouteName.OrganizationMemberDeleteAjax },
                new[]
            {
                new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName),
                new RouteExtensions.ObfuscatedPathMetadata(4, Obfuscator.DefaultTelemetryUserName)
            });

            routes.MapRoute(
                RouteName.OrganizationAccount,
                "organization/{accountName}/{action}",
                new { controller = "Organizations", action = "ManageOrganization" },
                new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName));

            routes.MapRoute(
                RouteName.ChangeOrganizationEmailSubscription,
                "organization/{accountName}/subscription/change",
                new { controller = "Organizations", action = "ChangeEmailSubscription" },
                new RouteExtensions.ObfuscatedPathMetadata(1, Obfuscator.DefaultTelemetryUserName));

            routes.MapRoute(
                RouteName.Downloads,
                "downloads",
                new { controller = "Pages", action = "Downloads" });

            routes.MapRoute(
                RouteName.ExperimentsSearchSideBySide,
                "experiments/search-sxs",
                new { controller = "Experiments", action = nameof(ExperimentsController.SearchSideBySide) });

            // TODO : Most of the routes are essentially of the format api/v{x}/*. We should refactor the code to vary them by the version.
            // V1 Routes
            // If the push url is /api/v1 then NuGet.Core would ping the path to resolve redirection.
            routes.MapRoute(
                "v1" + RouteName.VerifyPackageKey,
                "api/v1/verifykey/{id}/{version}",
                new
            {
                controller = "Api",
                action     = "VerifyPackageKey",
                version    = UrlParameter.Optional
            });

            routes.MapRoute(
                "v1" + RouteName.CreatePackageVerificationKey,
                "api/v1/package/create-verification-key/{id}/{version}",
                new
            {
                controller = "Api",
                action     = "CreatePackageVerificationKey",
                version    = UrlParameter.Optional
            });

            var downloadRoute = routes.MapRoute(
                "v1" + RouteName.DownloadPackage,
                "api/v1/package/{id}/{version}",
                defaults: new
            {
                controller = "Api",
                action     = "GetPackageApi",
                version    = UrlParameter.Optional
            },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                "v1" + RouteName.PushPackageApi,
                "v1/PackageFiles/{apiKey}/nupkg",
                defaults: new { controller = "Api", action = "PushPackageApi" },
                constraints: new { httpMethod = new HttpMethodConstraint("POST") });

            routes.MapRoute(
                "v1" + RouteName.DeletePackageApi,
                "v1/Packages/{apiKey}/{id}/{version}",
                new { controller = "Api", action = "DeletePackages" });

            routes.MapRoute(
                "v1" + RouteName.PublishPackageApi,
                "v1/PublishedPackages/Publish",
                new { controller = "Api", action = "PublishPackage" });

            // Redirected Legacy Routes

            routes.Redirect(
                r => r.MapRoute(
                    "ReportAbuse",
                    "Package/ReportAbuse/{id}/{version}",
                    new { controller = "Packages", action = "ReportAbuse" }),
                permanent: true).To(packageVersionActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.ListPackages,
                    "List/Packages",
                    new { controller = "Packages", action = "ListPackages" }),
                permanent: true).To(packageListRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.DisplayPackage,
                    "List/Packages/{id}/{version}",
                    new { controller = "Packages", action = "DisplayPackage", version = UrlParameter.Optional }),
                permanent: true).To(packageDisplayRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.NewSubmission,
                    "Contribute/NewSubmission",
                    new { controller = "Packages", action = "UploadPackage" }),
                permanent: true).To(uploadPackageRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "LegacyDownloadRoute",
                    "v1/Package/Download/{id}/{version}",
                    new { controller = "Api", action = "GetPackageApi", version = UrlParameter.Optional }),
                permanent: true).To(downloadRoute);
        }
Example #16
0
        public static void MapSeoRoutes(this RouteCollection routes)
        {
            var pageRoute =
                new NormalizeRoute(
                    new PageRoute(
                        Constants.PageRoute,
                        new RouteValueDictionary
            {
                { "controller", "Page" },
                { "action", "DisplayPageAsync" },
                //{ Constants.Language, UrlParameter.Optional }
            },
                        new RouteValueDictionary
            {
                { Constants.Language, new LanguageRouteConstraint() },
                { Constants.Store, new StoreRouteConstraint() },
                { Constants.Page, new PageRouteConstraint() }
            },
                        new RouteValueDictionary {
                { "namespaces", new[] { "VirtoCommerce.Web.Controllers" } }
            },
                        new MvcRouteHandler()));

            var itemRoute =
                new NormalizeRoute(
                    new ItemRoute(
                        Constants.ItemRoute,
                        new RouteValueDictionary
            {
                { "controller", "Product" },
                { "action", "ProductByKeywordAsync" },
                //{ Constants.Language, UrlParameter.Optional }
            },
                        new RouteValueDictionary
            {
                { Constants.Language, new LanguageRouteConstraint() },
                { Constants.Store, new StoreRouteConstraint() },
                { Constants.Category, new CategoryRouteConstraint() },
                { Constants.Item, new ItemRouteConstraint() }
            },
                        new RouteValueDictionary {
                { "namespaces", new[] { "VirtoCommerce.Web.Controllers" } }
            },
                        new MvcRouteHandler()));

            var categoryRoute =
                new NormalizeRoute(
                    new CategoryRoute(
                        Constants.CategoryRoute,
                        new RouteValueDictionary
            {
                { "controller", "Collections" },
                { "action", "GetCollectionByKeywordAsync" },
                //{ Constants.Language, UrlParameter.Optional },
                { Constants.Tags, UrlParameter.Optional },
            },
                        new RouteValueDictionary
            {
                { Constants.Language, new LanguageRouteConstraint() },
                { Constants.Store, new StoreRouteConstraint() },
                { Constants.Category, new CategoryRouteConstraint() }
            },
                        new RouteValueDictionary {
                { "namespaces", new[] { "VirtoCommerce.Web.Controllers" } }
            },
                        new MvcRouteHandler()));

            var storeRoute =
                new NormalizeRoute(
                    new StoreRoute(
                        Constants.StoreRoute,
                        new RouteValueDictionary {
                { "controller", "Home" }, { "action", "Index" }
            },
                        new RouteValueDictionary
            {
                { Constants.Language, new LanguageRouteConstraint() },
                { Constants.Store, new StoreRouteConstraint() }
            },
                        new RouteValueDictionary {
                { "namespaces", new[] { "VirtoCommerce.Web.Controllers" } }
            },
                        new MvcRouteHandler()));

            //Legacy redirects
            routes.Redirect(r => r.MapRoute("old_Collection", string.Format("collections/{{{0}}}", Constants.Category))).To(categoryRoute,
                                                                                                                            x =>
            {
                //Expect to receive category code
                if (x.RouteData.Values.ContainsKey(Constants.Category))
                {
                    var client   = ClientContext.Clients.CreateBrowseClient();
                    var store    = SiteContext.Current.Shop.StoreId;
                    var language = SiteContext.Current.Language;
                    var category = Task.Run(() => client.GetCategoryByCodeAsync(store, language, x.RouteData.Values[Constants.Category].ToString())).Result;
                    if (category != null)
                    {
                        var model = category.AsWebModel();
                        return(new RouteValueDictionary {
                            { Constants.Category, model.Outline }
                        });
                    }
                }
                return(null);
            });


            var defaultRoute = new NormalizeRoute(
                new Route(string.Format("{0}/{{controller}}/{{action}}/{{id}}", Constants.StoreRoute),
                          new RouteValueDictionary {
                { "id", UrlParameter.Optional },
                { "action", "Index" }
            },
                          new RouteValueDictionary
            {
                { Constants.Language, new LanguageRouteConstraint() },
                { Constants.Store, new StoreRouteConstraint() }
            },
                          new RouteValueDictionary {
                { "namespaces", new[] { "VirtoCommerce.Web.Controllers" } }
            },
                          new MvcRouteHandler()));

            routes.Add("Page", pageRoute);
            routes.Add("Item", itemRoute);
            routes.Add("Category", categoryRoute);
            routes.Add("Store", storeRoute);

            //Other actions
            routes.Add("RelativeDefault", defaultRoute);
        }
Example #17
0
        public static void RegisterUIRoutes(RouteCollection routes)
        {
            routes.MapRoute(
                RouteName.Home,
                "",
                new { controller = "Pages", action = "Home" }); // T4MVC doesn't work with Async Action

            routes.MapRoute(
                RouteName.Error500,
                "errors/500",
                new { controller = "Errors", action = "InternalError" });

            routes.MapRoute(
                RouteName.Error404,
                "errors/404",
                new { controller = "Errors", action = "NotFound" });

            routes.MapRoute(
                RouteName.StatisticsHome,
                "stats",
                new { controller = "Statistics", action = "Index" });

            routes.MapRoute(
                RouteName.Stats,
                "stats/totals",
                new { controller = "Statistics", action = "Totals" });

            routes.MapRoute(
                RouteName.StatisticsPackages,
                "stats/packages",
                new { controller = "Statistics", action = "Packages" });

            routes.MapRoute(
                RouteName.StatisticsPackageVersions,
                "stats/packageversions",
                new { controller = "Statistics", action = "PackageVersions" });

            routes.MapRoute(
                RouteName.StatisticsPackageDownloadsDetail,
                "stats/packages/{id}/{version}",
                new { controller = "Statistics", action = "PackageDownloadsDetail" });

            routes.MapRoute(
                RouteName.StatisticsPackageDownloadsByVersion,
                "stats/packages/{id}",
                new { controller = "Statistics", action = "PackageDownloadsByVersion" });
           
            routes.Add(new JsonRoute("json/{controller}"));

            routes.MapRoute(
                RouteName.Contributors,
                "pages/contributors",
                new { controller = "Pages", action = "Contributors" });

            routes.MapRoute(
                RouteName.Policies,
                "policies/{action}",
                new { controller = "Pages" });

            routes.MapRoute(
                RouteName.Pages,
                "pages/{pageName}",
                new { controller = "Pages", action = "Page" });

            var packageListRoute = routes.MapRoute(
                RouteName.ListPackages,
                "packages",
                new { controller = "Packages", action = "ListPackages" });

            var uploadPackageRoute = routes.MapRoute(
                RouteName.UploadPackage,
                "packages/upload",
                new { controller = "Packages", action = "UploadPackage" });

            routes.MapRoute(
                RouteName.UploadPackageProgress,
                "packages/upload-progress",
                new { controller = "Packages", action = "UploadPackageProgress" });

            routes.MapRoute(
                RouteName.VerifyPackage,
                "packages/verify-upload",
                new { controller = "Packages", action = "VerifyPackage" });

            routes.MapRoute(
                RouteName.CancelUpload,
                "packages/cancel-upload",
                new { controller = "Packages", action = "CancelUpload"});

            routes.MapRoute(
                RouteName.PackageOwnerConfirmation,
                "packages/{id}/owners/{username}/confirm/{token}",
                new { controller = "Packages", action = "ConfirmOwner" });

            // We need the following two routes (rather than just one) due to Routing's 
            // Consecutive Optional Parameter bug. :(
            var packageDisplayRoute = routes.MapRoute(
                RouteName.DisplayPackage,
                "packages/{id}/{version}",
                new { 
                    controller = "packages", 
                    action = "DisplayPackage", 
                    version = UrlParameter.Optional 
                },
                new { version = new VersionRouteConstraint() });

            routes.MapRoute(
                RouteName.PackageEnableLicenseReport,
                "packages/{id}/{version}/EnableLicenseReport",
                new { controller = "Packages", action = "SetLicenseReportVisibility", visible = true },
                new { version = new VersionRouteConstraint() });
            
            routes.MapRoute(
                RouteName.PackageDisableLicenseReport,
                "packages/{id}/{version}/DisableLicenseReport",
                new { controller = "Packages", action = "SetLicenseReportVisibility", visible = false },
                new { version = new VersionRouteConstraint() });

            var packageVersionActionRoute = routes.MapRoute(
                RouteName.PackageVersionAction,
                "packages/{id}/{version}/{action}",
                new { controller = "Packages" },
                new { version = new VersionRouteConstraint() });

            var packageActionRoute = routes.MapRoute(
                RouteName.PackageAction,
                "packages/{id}/{action}",
                new { controller = "Packages" });

            var confirmationRequiredRoute = routes.MapRoute(
                "ConfirmationRequired",
                "account/ConfirmationRequired",
                new { controller = "Users", action = "ConfirmationRequired" });

            //Redirecting v1 Confirmation Route
            routes.Redirect(
                r => r.MapRoute(
                    "v1Confirmation",
                    "Users/Account/ChallengeEmail")).To(confirmationRequiredRoute);

            routes.MapRoute(
                RouteName.ExternalAuthenticationCallback,
                "users/account/authenticate/return",
                new { controller = "Authentication", action = "LinkExternalAccount" });

            routes.MapRoute(
                RouteName.ExternalAuthentication,
                "users/account/authenticate/{provider}",
                new { controller = "Authentication", action = "Authenticate" });

            routes.MapRoute(
                RouteName.Authentication,
                "users/account/{action}",
                new { controller = "Authentication" });

            routes.MapRoute(
                RouteName.Profile,
                "profiles/{username}",
                new { controller = "Users", action = "Profiles" });

            routes.MapRoute(
                RouteName.LegacyRegister,
                "account/register",
                new { controller = "Authentication", action = "Register" });

            routes.MapRoute(
                RouteName.RemovePassword,
                "account/RemoveCredential/password",
                new { controller = "Users", action = "RemovePassword" });

            routes.MapRoute(
                RouteName.RemoveCredential,
                "account/RemoveCredential/{credentialType}",
                new { controller = "Users", action = "RemoveCredential" });

            routes.MapRoute(
                RouteName.PasswordReset,
                "account/forgotpassword/{username}/{token}",
                new { controller = "Users", action = "ResetPassword", forgot = true });

            routes.MapRoute(
                RouteName.PasswordSet,
                "account/setpassword/{username}/{token}",
                new { controller = "Users", action = "ResetPassword", forgot = false });

            routes.MapRoute(
                RouteName.ConfirmAccount,
                "account/confirm/{username}/{token}",
                new { controller = "Users", action = "Confirm" });

            routes.MapRoute(
                RouteName.SubscribeToEmails,
                "account/subscribe",
                new { controller = "Users", action = "ChangeEmailSubscription", subscribe = true });

            routes.MapRoute(
                RouteName.UnsubscribeFromEmails,
                "account/unsubscribe",
                new { controller = "Users", action = "ChangeEmailSubscription", subscribe = false });

            routes.MapRoute(
                RouteName.Account,
                "account/{action}",
                new { controller = "Users", action = "Account" });

            routes.MapRoute(
                RouteName.CuratedFeed,
                "curated-feeds/{name}",
                new { controller = "CuratedFeeds", action = "CuratedFeed" });

            routes.MapRoute(
                RouteName.CuratedFeedListPackages,
                "curated-feeds/{curatedFeedName}/packages",
                new { controller = "CuratedFeeds", action = "ListPackages" });

            routes.MapRoute(
                RouteName.CreateCuratedPackageForm,
                "forms/add-package-to-curated-feed",
                new { controller = "CuratedPackages", action = "CreateCuratedPackageForm" });

            routes.MapRoute(
                RouteName.CuratedPackage,
                "curated-feeds/{curatedFeedName}/curated-packages/{curatedPackageId}",
                new { controller = "CuratedPackages", action = "CuratedPackage" });

            routes.MapRoute(
                RouteName.CuratedPackages,
                "curated-feeds/{curatedFeedName}/curated-packages",
                new { controller = "CuratedPackages", action = "CuratedPackages" });

            // TODO : Most of the routes are essentially of the format api/v{x}/*. We should refactor the code to vary them by the version.
            // V1 Routes
            // If the push url is /api/v1 then NuGet.Core would ping the path to resolve redirection. 
            routes.MapRoute(
                "v1" + RouteName.VerifyPackageKey,
                "api/v1/verifykey/{id}/{version}",
                new { 
                    controller = "Api", 
                    action = "VerifyPackageKey", 
                    id = UrlParameter.Optional, 
                    version = UrlParameter.Optional 
                });

            var downloadRoute = routes.MapRoute(
                "v1" + RouteName.DownloadPackage,
                "api/v1/package/{id}/{version}",
                defaults: new { 
                    controller = "Api", 
                    action = "GetPackageApi", 
                    version = UrlParameter.Optional 
                },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                "v1" + RouteName.PushPackageApi,
                "v1/PackageFiles/{apiKey}/nupkg",
                defaults: new { controller = "Api", action = "PushPackageApi" },
                constraints: new { httpMethod = new HttpMethodConstraint("POST") });

            routes.MapRoute(
                "v1" + RouteName.DeletePackageApi,
                "v1/Packages/{apiKey}/{id}/{version}",
                new { controller = "Api", action = "DeletePackages" });

            routes.MapRoute(
                "v1" + RouteName.PublishPackageApi,
                "v1/PublishedPackages/Publish",
                new { controller = "Api", action = "PublishPackage" });

            // Redirected Legacy Routes

            routes.Redirect(
                r => r.MapRoute(
                    "ReportAbuse",
                    "Package/ReportAbuse/{id}/{version}",
                    new { controller = "Packages", action = "ReportAbuse" }),
                permanent: true).To(packageVersionActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "PackageActions",
                    "Package/{action}/{id}",
                    new { controller = "Packages", action = "ContactOwners" },
                    // This next bit looks bad, but it's not. It will never change because
                    // it's mapping the legacy routes to the new better routes.
                    new { action = "ContactOwners|ManagePackageOwners" }),
                permanent: true).To(packageActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.ListPackages,
                    "List/Packages",
                    new { controller = "Packages", action = "ListPackages" }),
                permanent: true).To(packageListRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.DisplayPackage,
                    "List/Packages/{id}/{version}",
                    new { controller = "Packages", action = "DisplayPackage", version = UrlParameter.Optional }),
                permanent: true).To(packageDisplayRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.NewSubmission,
                    "Contribute/NewSubmission",
                    new { controller = "Packages", action = "UploadPackage" }),
                permanent: true).To(uploadPackageRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "LegacyDownloadRoute",
                    "v1/Package/Download/{id}/{version}",
                    new { controller = "Api", action = "GetPackageApi", version = UrlParameter.Optional }),
                permanent: true).To(downloadRoute);
        }
Example #18
0
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.MapRoute(
                RouteName.Home,
                "",
                new { controller = MVC.Pages.Name, action = "Home" }); // T4MVC doesn't work with Async Action

            routes.MapRoute(
                RouteName.StatisticsHome,
                "stats",
                new { controller = MVC.Statistics.Name, action = "Index" });

            routes.MapRoute(
                RouteName.Stats,
                "stats/totals",
                MVC.Statistics.Totals());

            routes.MapRoute(
                RouteName.StatisticsPackages,
                "stats/packages",
                new { controller = MVC.Statistics.Name, action = "Packages" });

            routes.MapRoute(
                RouteName.StatisticsPackageVersions,
                "stats/packageversions",
                new { controller = MVC.Statistics.Name, action = "PackageVersions" });

            routes.MapRoute(
                RouteName.StatisticsPackageDownloadsDetail,
                "stats/packages/{id}/{version}",
                new { controller = MVC.Statistics.Name, action = "PackageDownloadsDetail" });

            routes.MapRoute(
                RouteName.StatisticsPackageDownloadsByVersion,
                "stats/packages/{id}",
                new { controller = MVC.Statistics.Name, action = "PackageDownloadsByVersion" });
           
            routes.Add(new JsonRoute("json/{controller}"));

            routes.MapRoute(
                RouteName.Policies,
                "policies/{action}",
                MVC.Pages.Terms());

            var packageListRoute = routes.MapRoute(
                RouteName.ListPackages,
                "packages",
                MVC.Packages.ListPackages());

            var uploadPackageRoute = routes.MapRoute(
                RouteName.UploadPackage,
                "packages/upload",
                new { controller = MVC.Packages.Name, action = "UploadPackage" });

            routes.MapRoute(
                RouteName.UploadPackageProgress,
                "packages/upload-progress",
                MVC.Packages.UploadPackageProgress());

            routes.MapRoute(
                RouteName.VerifyPackage,
                "packages/verify-upload",
                new { controller = MVC.Packages.Name, action = "VerifyPackage" });

            routes.MapRoute(
                RouteName.CancelUpload,
                "packages/cancel-upload",
                new { controller = MVC.Packages.Name, action = "CancelUpload"});

            routes.MapRoute(
                RouteName.PackageOwnerConfirmation,
                "packages/{id}/owners/{username}/confirm/{token}",
                new { controller = MVC.Packages.Name, action = "ConfirmOwner" });

            // We need the following two routes (rather than just one) due to Routing's 
            // Consecutive Optional Parameter bug. :(
            var packageDisplayRoute = routes.MapRoute(
                RouteName.DisplayPackage,
                "packages/{id}/{version}",
                MVC.Packages.DisplayPackage().AddRouteValue("version", UrlParameter.Optional),
                null /*defaults*/,
                new { version = new VersionRouteConstraint() });

            var packageVersionActionRoute = routes.MapRoute(
                RouteName.PackageVersionAction,
                "packages/{id}/{version}/{action}",
                new { controller = MVC.Packages.Name },
                new { version = new VersionRouteConstraint() });

            var packageActionRoute = routes.MapRoute(
                RouteName.PackageAction,
                "packages/{id}/{action}",
                new { controller = MVC.Packages.Name });

            var resendRoute = routes.MapRoute(
                "ResendConfirmation",
                "account/ResendConfirmation",
                MVC.Users.ResendConfirmation());

            //Redirecting v1 Confirmation Route
            routes.Redirect(
                r => r.MapRoute(
                    "v1Confirmation",
                    "Users/Account/ChallengeEmail")).To(resendRoute);

            routes.MapRoute(
                RouteName.Authentication,
                "users/account/{action}",
                new { controller = MVC.Authentication.Name });

            routes.MapRoute(
                RouteName.Profile,
                "profiles/{username}",
                MVC.Users.Profiles());

            routes.MapRoute(
                RouteName.PasswordReset,
                "account/{action}/{username}/{token}",
                MVC.Users.ResetPassword());

            routes.MapRoute(
                RouteName.Account,
                "account/{action}",
                MVC.Users.Account());

            routes.MapRoute(
                RouteName.CuratedFeed,
                "curated-feeds/{name}",
                new { controller = CuratedFeedsController.ControllerName, action = "CuratedFeed" });

            routes.MapRoute(
                RouteName.CuratedFeedListPackages,
                "curated-feeds/{curatedFeedName}/packages",
                MVC.CuratedFeeds.ListPackages());

            routes.MapRoute(
                RouteName.CreateCuratedPackageForm,
                "forms/add-package-to-curated-feed",
                new { controller = CuratedPackagesController.ControllerName, action = "CreateCuratedPackageForm" });

            routes.MapRoute(
                RouteName.CuratedPackage,
                "curated-feeds/{curatedFeedName}/curated-packages/{curatedPackageId}",
                new { controller = CuratedPackagesController.ControllerName, action = "CuratedPackage" });

            routes.MapRoute(
                RouteName.CuratedPackages,
                "curated-feeds/{curatedFeedName}/curated-packages",
                new { controller = CuratedPackagesController.ControllerName, action = "CuratedPackages" });

            // TODO : Most of the routes are essentially of the format api/v{x}/*. We should refactor the code to vary them by the version.
            // V1 Routes
            // If the push url is /api/v1 then NuGet.Core would ping the path to resolve redirection. 
            routes.MapRoute(
                "v1" + RouteName.VerifyPackageKey,
                "api/v1/verifykey/{id}/{version}",
                MVC.Api.VerifyPackageKey(),
                defaults: new { id = UrlParameter.Optional, version = UrlParameter.Optional });

            var downloadRoute = routes.MapRoute(
                "v1" + RouteName.DownloadPackage,
                "api/v1/package/{id}/{version}",
                defaults: new { controller = MVC.Api.Name, action = "GetPackageApi", version = UrlParameter.Optional },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                "v1" + RouteName.PushPackageApi,
                "v1/PackageFiles/{apiKey}/nupkg",
                defaults: new { controller = MVC.Api.Name, action = "PushPackageApi" },
                constraints: new { httpMethod = new HttpMethodConstraint("POST") });

            routes.MapRoute(
                "v1" + RouteName.DeletePackageApi,
                "v1/Packages/{apiKey}/{id}/{version}",
                MVC.Api.DeletePackage());

            routes.MapRoute(
                "v1" + RouteName.PublishPackageApi,
                "v1/PublishedPackages/Publish",
                MVC.Api.PublishPackage());

            // V2 routes
            routes.MapRoute(
                "v2" + RouteName.VerifyPackageKey,
                "api/v2/verifykey/{id}/{version}",
                MVC.Api.VerifyPackageKey(),
                defaults: new { id = UrlParameter.Optional, version = UrlParameter.Optional });

            routes.MapRoute(
                "v2CuratedFeeds" + RouteName.DownloadPackage,
                "api/v2/curated-feeds/package/{id}/{version}",
                defaults: new { controller = MVC.Api.Name, action = "GetPackageApi", version = UrlParameter.Optional },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                "v2" + RouteName.DownloadPackage,
                "api/v2/package/{id}/{version}",
                defaults: new { controller = MVC.Api.Name, action = "GetPackageApi", version = UrlParameter.Optional },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                "v2" + RouteName.PushPackageApi,
                "api/v2/package",
                defaults: new { controller = MVC.Api.Name, action = "PushPackageApi" },
                constraints: new { httpMethod = new HttpMethodConstraint("PUT") });

            routes.MapRoute(
                "v2" + RouteName.DeletePackageApi,
                "api/v2/package/{id}/{version}",
                MVC.Api.DeletePackage(),
                defaults: null,
                constraints: new { httpMethod = new HttpMethodConstraint("DELETE") });

            routes.MapRoute(
                "v2" + RouteName.PublishPackageApi,
                "api/v2/package/{id}/{version}",
                MVC.Api.PublishPackage(),
                defaults: null,
                constraints: new { httpMethod = new HttpMethodConstraint("POST") });

            routes.MapRoute(
                "v2PackageIds",
                "api/v2/package-ids",
                MVC.Api.GetPackageIds());

            routes.MapRoute(
                "v2PackageVersions",
                "api/v2/package-versions/{id}",
                MVC.Api.GetPackageVersions());

            routes.MapRoute(
                RouteName.StatisticsDownloadsApi,
                "api/v2/stats/downloads/last6weeks",
                defaults: new { controller = MVC.Api.Name, action = "StatisticsDownloadsApi" },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                RouteName.ServiceAlert,
                "api/v2/service-alert",
                defaults: new { controller = MVC.Api.Name, action = "ServiceAlert" },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                RouteName.DownloadNuGetExe,
                "nuget.exe",
                new { controller = MVC.Api.Name, action = "GetNuGetExeApi" });

            // Redirected Legacy Routes

            routes.Redirect(
                r => r.MapRoute(
                    "ReportAbuse",
                    "Package/ReportAbuse/{id}/{version}",
                    MVC.Packages.ReportAbuse()),
                permanent: true).To(packageVersionActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "PackageActions",
                    "Package/{action}/{id}",
                    MVC.Packages.ContactOwners(),
                    null /*defaults*/,
                    // This next bit looks bad, but it's not. It will never change because 
                    // it's mapping the legacy routes to the new better routes.
                    new { action = "ContactOwners|ManagePackageOwners" }),
                permanent: true).To(packageActionRoute);


            // TODO: this route looks broken as there is no EditPackage action
            //routes.Redirect(
            //    r => r.MapRoute(
            //        "EditPackage",
            //        "Package/Edit/{id}/{version}",
            //        new { controller = PackagesController.ControllerName, action = "EditPackage" }),
            //    permanent: true).To(packageVersionActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.ListPackages,
                    "List/Packages",
                    MVC.Packages.ListPackages()),
                permanent: true).To(packageListRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.DisplayPackage,
                    "List/Packages/{id}/{version}",
                    MVC.Packages.DisplayPackage().AddRouteValue("version", UrlParameter.Optional)),
                permanent: true).To(packageDisplayRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.NewSubmission,
                    "Contribute/NewSubmission",
                    new { controller = MVC.Packages.Name, action = "UploadPackage" }),
                permanent: true).To(uploadPackageRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "LegacyDownloadRoute",
                    "v1/Package/Download/{id}/{version}",
                    new { controller = MVC.Api.Name, action = "GetPackageApi", version = UrlParameter.Optional }),
                permanent: true).To(downloadRoute);
        }
Example #19
0
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.MapRoute(
                RouteName.Home,
                "",
                MVC.Pages.Home());

            routes.Add(new JsonRoute("json/{controller}"));

            routes.MapRoute(
                RouteName.Policies,
                "policies/{action}",
                MVC.Pages.Terms());

            var packageListRoute = routes.MapRoute(
                RouteName.ListPackages,
                "packages",
                MVC.Packages.ListPackages());

            var uploadPackageRoute = routes.MapRoute(
                RouteName.UploadPackage,
                "packages/upload",
                MVC.Packages.UploadPackage());

            routes.MapRoute(
                RouteName.VerifyPackage,
                "packages/verify-upload",
                MVC.Packages.VerifyPackage());

            routes.MapRoute(
                RouteName.CancelUpload,
                "packages/cancel-upload",
                MVC.Packages.CancelUpload());

            routes.MapRoute(
                RouteName.PackageOwnerConfirmation,
                "packages/{id}/owners/{username}/confirm/{token}",
                new { controller = MVC.Packages.Name, action = "ConfirmOwner" });

            // We need the following two routes (rather than just one) due to Routing's
            // Consecutive Optional Parameter bug. :(
            var packageDisplayRoute = routes.MapRoute(
                RouteName.DisplayPackage,
                "packages/{id}/{version}",
                MVC.Packages.DisplayPackage().AddRouteValue("version", UrlParameter.Optional),
                null /*defaults*/,
                new { version = new VersionRouteConstraint() });

            var packageVersionActionRoute = routes.MapRoute(
                RouteName.PackageVersionAction,
                "packages/{id}/{version}/{action}",
                new { controller = MVC.Packages.Name },
                new { version = new VersionRouteConstraint() });

            var packageActionRoute = routes.MapRoute(
                RouteName.PackageAction,
                "packages/{id}/{action}",
                new { controller = MVC.Packages.Name });

            var resendRoute = routes.MapRoute(
               "ResendConfirmation",
               "account/ResendConfirmation",
               MVC.Users.ResendConfirmation());

            //Redirecting v1 Confirmation Route
            routes.Redirect(
               r => r.MapRoute(
                   "v1Confirmation",
                   "Users/Account/ChallengeEmail")).To(resendRoute);

            routes.MapRoute(
                RouteName.Authentication,
                "users/account/{action}",
                new { controller = MVC.Authentication.Name });

            routes.MapRoute(
                RouteName.Profile,
                "profiles/{username}",
                MVC.Users.Profiles());

            routes.MapRoute(
                RouteName.PasswordReset,
                "account/{action}/{username}/{token}",
                MVC.Users.ResetPassword());

            routes.MapRoute(
                RouteName.Account,
                "account/{action}",
                MVC.Users.Account());

            // TODO : Most of the routes are essentially of the format api/v{x}/*. We should refactor the code to vary them by the version.
            // V1 Routes
            // If the push url is /api/v1 then NuGet.Core would ping the path to resolve redirection.
            routes.MapServiceRoute(
                RouteName.V1ApiFeed,
                "api/v1/FeedService.svc",
                typeof(V1Feed));

            routes.MapServiceRoute(
                "LegacyFeedService",
                "v1/FeedService.svc",
                typeof(V1Feed));

            routes.MapRoute(
                "v1" + RouteName.VerifyPackageKey,
                "api/v1/package/verifykey/{id}/{version}",
                MVC.Api.VerifyPackageKey());

            var downloadRoute = routes.MapRoute(
                "v1" + RouteName.DownloadPackage,
                "api/v1/package/{id}/{version}",
                MVC.Api.GetPackage(),
                defaults: new { version = UrlParameter.Optional },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                "v1" + RouteName.PushPackageApi,
                "v1/PackageFiles/{apiKey}/nupkg",
                MVC.Api.CreatePackagePost());

            routes.MapRoute(
                "v1" + RouteName.DeletePackageApi,
                "v1/Packages/{apiKey}/{id}/{version}",
                MVC.Api.DeletePackage());

            routes.MapRoute(
                "v1" + RouteName.PublishPackageApi,
                "v1/PublishedPackages/Publish",
                MVC.Api.PublishPackage());

            routes.MapServiceRoute(
                "v1" + RouteName.V1ApiFeed,
                "api/v1",
                typeof(V1Feed));

            // V2 routes
            routes.MapRoute(
                "v2" + RouteName.VerifyPackageKey,
                "api/v2/package/verifykey/{id}/{version}",
                MVC.Api.VerifyPackageKey());

            routes.MapRoute(
                "v2" + RouteName.DownloadPackage,
                "api/v2/package/{id}/{version}",
                MVC.Api.GetPackage(),
                defaults: new { version = UrlParameter.Optional },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                "v2" + RouteName.PushPackageApi,
                "api/v2/package",
                MVC.Api.CreatePackagePut(),
                defaults: null,
                constraints: new { httpMethod = new HttpMethodConstraint("PUT") });

            routes.MapRoute(
                "v2" + RouteName.DeletePackageApi,
                "api/v2/package/{id}/{version}",
                MVC.Api.DeletePackage(),
                defaults: null,
                constraints: new { httpMethod = new HttpMethodConstraint("DELETE") });

            routes.MapServiceRoute(
                RouteName.V2ApiFeed,
                "api/v2/",
                typeof(V2Feed));

            // Redirected Legacy Routes

            routes.Redirect(
                r => r.MapRoute(
                    "ReportAbuse",
                    "Package/ReportAbuse/{id}/{version}",
                    MVC.Packages.ReportAbuse()),
                permanent: true).To(packageVersionActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "PackageActions",
                    "Package/{action}/{id}",
                    MVC.Packages.ContactOwners(),
                    null /*defaults*/,
                    // This next bit looks bad, but it's not. It will never change because
                    // it's mapping the legacy routes to the new better routes.
                    new { action = "ContactOwners|ManagePackageOwners" }),
                permanent: true).To(packageActionRoute);

            // TODO: this route looks broken as there is no EditPackage action
            //routes.Redirect(
            //    r => r.MapRoute(
            //        "EditPackage",
            //        "Package/Edit/{id}/{version}",
            //        new { controller = PackagesController.Name, action = "EditPackage" }),
            //    permanent: true).To(packageVersionActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.ListPackages,
                    "List/Packages",
                    MVC.Packages.ListPackages()),
                permanent: true).To(packageListRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.DisplayPackage,
                    "List/Packages/{id}/{version}",
                    MVC.Packages.DisplayPackage().AddRouteValue("version", UrlParameter.Optional)),
                permanent: true).To(packageDisplayRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.NewSubmission,
                    "Contribute/NewSubmission",
                    MVC.Packages.UploadPackage()),
                permanent: true).To(uploadPackageRoute);

            routes.Redirect(
               r => r.MapRoute(
                   "LegacyDownloadRoute",
                   "v1/Package/Download/{id}/{version}",
                   MVC.Api.GetPackage().AddRouteValue("version", UrlParameter.Optional)),
               permanent: true).To(downloadRoute);
        }
Example #20
0
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            var targetRoute = routes.MapRoute("", "Home/Index", new { controller = "Home", action = "Index" });
            var donar       = routes.MapRoute("", "StaticContent/Donar", new { controller = "StaticContent", action = "Donar" });
            var faq         = routes.MapRoute("", "StaticContent/Faq", new { controller = "StaticContent", action = "Faq" });
            var libre       = routes.MapRoute("", "StaticContent/Libre", new { controller = "StaticContent", action = "Libre" });
            var manoton     = routes.MapRoute("", "StaticContent/Manoton", new { controller = "StaticContent", action = "Manoton" });
            var embajadores = routes.MapRoute("", "StaticContent/Embajadores", new { controller = "StaticContent", action = "Embajadores" });
            var animales    = routes.MapRoute("", "StaticContent/Animales", new { controller = "StaticContent", action = "Animales" });
            var lista       = routes.MapRoute("", "Orders/PublicOrders", new { controller = "Orders", action = "PublicOrders", area = "" }, new[] { "Limbs.Web.Controllers" });

            routes.Redirect(r => r.MapRoute("", "faq")).To(faq);
            routes.Redirect(r => r.MapRoute("", "dar")).To(donar);
            routes.Redirect(r => r.MapRoute("", "donar")).To(donar);
            routes.Redirect(r => r.MapRoute("", "libre")).To(libre);
            routes.Redirect(r => r.MapRoute("", "manoton")).To(manoton);
            routes.Redirect(r => r.MapRoute("", "pedir")).To(targetRoute);
            routes.Redirect(r => r.MapRoute("", "pedir-una-mano")).To(targetRoute);
            routes.Redirect(r => r.MapRoute("", "embajador-atomico")).To(embajadores);
            routes.Redirect(r => r.MapRoute("", "SerEmbajador")).To(embajadores);
            routes.Redirect(r => r.MapRoute("", "SerVoluntario")).To(embajadores);
            routes.Redirect(r => r.MapRoute("", "donations/limbs")).To(donar);
            routes.Redirect(r => r.MapRoute("", "animales")).To(animales);
            routes.Redirect(r => r.MapRoute("", "ListaDeEspera")).To(lista);

            routes.MapRoute("", "covid", new { controller = "Covid", action = "Create" });
            routes.MapRoute("", "covid/pedido", new { controller = "Covid", action = "Edit" });

            routes.MapRoute(
                name: "Localized",
                url: "{lang}/{controller}/{action}/{id}",
                constraints: new { lang = @"(\w{2})|(\w{2}-\w{2})" },
                defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional }
                );

            routes.MapRoute(
                "Default",
                "{controller}/{action}/{id}",
                new { controller = "Home", action = "Index", id = UrlParameter.Optional },
                new[] { "Limbs.Web.Controllers" }
                ).SetRouteName("Default");

            routes.MapRoute(
                "404-PageNotFound",
                "{*url}",
                new { controller = "StaticContent", action = "PageNotFound" }
                );
        }
Example #21
0
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{*favicon}", new { favicon = @"(.*/)?favicon.ico(/.*)?" });
            routes.IgnoreRoute("{*Content}", new { imgs = @"(.*/)?Content(/.*)?" });
            routes.IgnoreRoute("{*Scripts}", new { scripts = @"(.*/)?Scripts(/.*)?" });

            routes.MapRoute(RouteName.Home, "", MVC.Pages.Home());

            routes.MapRoute(
                RouteName.About, "about", new
                {
                    controller = "Pages",
                    Action = "About"
                });

            routes.MapRoute(
                RouteName.InstallerBatchFile, "installChocolatey.cmd", new
                {
                    controller = "Pages",
                    Action = "InstallerBatchFile"
                });

            routes.MapRoute(
                RouteName.Notice, "notice", new
                {
                    controller = "Pages",
                    Action = "Notice"
                });

            routes.MapRoute(RouteName.Stats, "stats", MVC.Pages.Stats());

            routes.MapRoute(
                "rss feed", "feed.rss", new
                {
                    controller = "RSS",
                    Action = "feed.rss"
                });

            routes.Add(new JsonRoute("json/{controller}"));

            routes.MapRoute(RouteName.Policies, "policies/{action}", MVC.Pages.Terms());

            var packageListRoute = routes.MapRoute(RouteName.ListPackages, "packages", MVC.Packages.ListPackages());

            routes.MapRoute(
                RouteName.NotifyComment, "packages/{packageId}/notify-comment", new
                {
                    controller = MVC.Packages.Name,
                    action = "NotifyMaintainersOfAddedComment"
                });

            var uploadPackageRoute = routes.MapRoute(RouteName.UploadPackage, "packages/upload", MVC.Packages.UploadPackage());

            routes.MapRoute(RouteName.VerifyPackage, "packages/verify-upload", MVC.Packages.VerifyPackage());

            routes.MapRoute(RouteName.CancelUpload, "packages/cancel-upload", MVC.Packages.CancelUpload());

            routes.MapRoute(
                RouteName.PackageOwnerConfirmation, "packages/{id}/owners/{username}/confirm/{token}", new
                {
                    controller = MVC.Packages.Name,
                    action = "ConfirmOwner"
                });

            // We need the following two routes (rather than just one) due to Routing's 
            // Consecutive Optional Parameter bug. :(
            var packageDisplayRoute = routes.MapRoute(
                RouteName.DisplayPackage, "packages/{id}/{version}", MVC.Packages.DisplayPackage().AddRouteValue("version", UrlParameter.Optional), null /*defaults*/, new
                {
                    version = new VersionRouteConstraint()
                });

            var packageVersionActionRoute = routes.MapRoute(
                RouteName.PackageVersionAction, "packages/{id}/{version}/{action}", new
                {
                    controller = MVC.Packages.Name
                }, new
                {
                    version = new VersionRouteConstraint()
                });

            var packageActionRoute = routes.MapRoute(
                RouteName.PackageAction, "packages/{id}/{action}", new
                {
                    controller = MVC.Packages.Name
                });

            var resendRoute = routes.MapRoute("ResendConfirmation", "account/ResendConfirmation", MVC.Users.ResendConfirmation());

            //Redirecting v1 Confirmation Route
            routes.Redirect(r => r.MapRoute("v1Confirmation", "Users/Account/ChallengeEmail")).To(resendRoute);

            routes.MapRoute(
                RouteName.Authentication, "users/account/{action}", new
                {
                    controller = MVC.Authentication.Name
                });

            routes.MapRoute(RouteName.Profile, "profiles/{username}", MVC.Users.Profiles());

            routes.MapRoute(RouteName.PasswordReset, "account/{action}/{username}/{token}", MVC.Users.ResetPassword());

            routes.MapRoute(RouteName.Account, "account/{action}", MVC.Users.Account());

            routes.MapRoute(
                "site" + RouteName.DownloadPackage, "packages/{id}/{version}/DownloadPackage", MVC.Api.GetPackage(), defaults: new
                {
                    version = UrlParameter.Optional
                }, constraints: new
                {
                    httpMethod = new HttpMethodConstraint("GET")
                });
            
            // V1 Routes
            routes.MapRoute("v1Legacy" + RouteName.PushPackageApi, "PackageFiles/{apiKey}/nupkg", MVC.Api.CreatePackagePost());
            routes.MapRoute("v1Legacy" + RouteName.PublishPackageApi, "PublishedPackages/Publish", MVC.Api.PublishPackage());

            // V2 routes
            routes.MapRoute(
                "v2" + RouteName.VerifyPackageKey, "api/v2/verifykey/{id}/{version}", MVC.Api.VerifyPackageKey(), defaults: new
                {
                    id = UrlParameter.Optional,
                    version = UrlParameter.Optional
                });

            routes.MapRoute(
                "v2" + RouteName.DownloadPackage, "api/v2/package/{id}/{version}", MVC.Api.GetPackage(), defaults: new
                {
                    version = UrlParameter.Optional
                }, constraints: new
                {
                    httpMethod = new HttpMethodConstraint("GET")
                });

            routes.MapRoute(
                "v2" + RouteName.PushPackageApi, "api/v2/package", MVC.Api.CreatePackagePut(), defaults: null, constraints: new
                {
                    httpMethod = new HttpMethodConstraint("PUT")
                });

            routes.MapRoute(
                "v2" + RouteName.DeletePackageApi, "api/v2/package/{id}/{version}", MVC.Api.DeletePackage(), defaults: null, constraints: new
                {
                    httpMethod = new HttpMethodConstraint("DELETE")
                });

            routes.MapRoute(
                "v2" + RouteName.PublishPackageApi, "api/v2/package/{id}/{version}", MVC.Api.PublishPackage(), defaults: null, constraints: new
                {
                    httpMethod = new HttpMethodConstraint("POST")
                });

            routes.MapServiceRoute(RouteName.V2ApiSubmittedFeed, "api/v2/submitted", typeof(V2SubmittedFeed));

            //routes.MapRoute("v2" + RouteName.TestPackageApi, "api/v2/test/{id}/{version}",
            //     new {controller = "Api", action = "TestPackageApi"}
            //     );

            routes.MapRoute(
                 "v2" + RouteName.TestPackageApi, 
                 "api/v2/test/{id}/{version}", 
                 MVC.Api.TestPackage(), 
                 defaults: null,
                 constraints: new
                 {
                    httpMethod = new HttpMethodConstraint("POST")
                 }
            );
            
            routes.MapRoute(
                 "v2" + RouteName.ValidatePackageApi, 
                 "api/v2/validate/{id}/{version}",
                 MVC.Api.ValidatePackage(), 
                 defaults: null,
                 constraints: new
                 {
                    httpMethod = new HttpMethodConstraint("POST")
                 }
            );
            
            routes.MapRoute(
                 "v2" + RouteName.CleanupPackageApi, 
                 "api/v2/cleanup/{id}/{version}",
                 MVC.Api.CleanupPackage(), 
                 defaults: null,
                 constraints: new
                 {
                    httpMethod = new HttpMethodConstraint("POST")
                 }
            );   
            
            routes.MapRoute(
                 "v2" + RouteName.DownloadCachePackageApi,
                 "api/v2/cache/{id}/{version}",
                 MVC.Api.DownloadCachePackage(), 
                 defaults: null,
                 constraints: new
                 {
                    httpMethod = new HttpMethodConstraint("POST")
                 }
            );
            
            routes.MapRoute("v2PackageIds", "api/v2/package-ids", MVC.Api.GetPackageIds());

            routes.MapRoute("v2PackageVersions", "api/v2/package-versions/{id}", MVC.Api.GetPackageVersions());

            routes.MapServiceRoute(RouteName.V2ApiFeed, "api/v2/", typeof(V2Feed));

            // Redirected Legacy Routes

            routes.Redirect(r => r.MapRoute("ReportAbuse", "Package/ReportAbuse/{id}/{version}", MVC.Packages.ReportAbuse()), permanent: true).To(packageVersionActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "PackageActions", "Package/{action}/{id}", MVC.Packages.ContactOwners(), null /*defaults*/, // This next bit looks bad, but it's not. It will never change because 
                    // it's mapping the legacy routes to the new better routes.
                    new
                    {
                        action = "ContactOwners|ManagePackageOwners"
                    }), permanent: true).To(packageActionRoute);

            // TODO: this route looks broken as there is no EditPackage action
            //routes.Redirect(
            //    r => r.MapRoute(
            //        "EditPackage",
            //        "Package/Edit/{id}/{version}",
            //        new { controller = PackagesController.ControllerName, action = "EditPackage" }),
            //    permanent: true).To(packageVersionActionRoute);

            routes.Redirect(r => r.MapRoute(RouteName.ListPackages, "List/Packages", MVC.Packages.ListPackages()), permanent: true).To(packageListRoute);

            routes.Redirect(r => r.MapRoute(RouteName.DisplayPackage, "List/Packages/{id}/{version}", MVC.Packages.DisplayPackage().AddRouteValue("version", UrlParameter.Optional)), permanent: true)
                  .To(packageDisplayRoute);

            routes.Redirect(r => r.MapRoute(RouteName.NewSubmission, "Contribute/NewSubmission", MVC.Packages.UploadPackage()), permanent: true).To(uploadPackageRoute);
        }
Example #22
0
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.Redirect("subte", "/api/subte");
            routes.Redirect("trenes", "/api/tren");
            routes.Redirect("bicicletas", "/api/bicicleta");
            routes.Redirect("divisa", "/api/cotizacion/divisas");
            routes.Redirect("api/cotizacion", "/api/cotizacion/divisas");
            routes.Redirect("divisa/rofex", "/api/cotizacion/rofex");
            routes.Redirect("transporte/cercano", "/api/transporte/");
            routes.Redirect("transporte/porlinea", "/api/transporte/");
            routes.Redirect("sube/recarganear", "/api/recargasube/");
            routes.Redirect("sube/ventanear", "/api/ventasube/");
            routes.Redirect("aviones/arribos", "/api/avion/arribos");
            routes.Redirect("aviones/partidas", "/api/avion/partidas");
            routes.Redirect("azurelog", "/status/ok");
            routes.Redirect("home/index", "/status/ok");
            routes.Redirect("dreamspark", "/status/ok");
            routes.Redirect("report/error", "/status/ok");

            routes.MapRoute(
                name: "Default",
                url: "{controller}/{action}/{id}",
                defaults: new { controller = "Status", action = "Ok", id = UrlParameter.Optional }
                );
        }
Example #23
0
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.MapRoute(
                RouteName.Home,
                "",
                MVC.Pages.Home());

            routes.Add(new JsonRoute("json/{controller}"));

            routes.MapRoute(
                RouteName.Policies,
                "policies/{action}",
                MVC.Pages.Terms());

            var packageListRoute = routes.MapRoute(
                RouteName.ListPackages,
                "packages",
                MVC.Packages.ListPackages());

            routes.MapRoute(
                RouteName.UploadPackage,
                "upload/package",
                MVC.Packages.UploadPackage());

            // We need the following two routes (rather than just one) due to Routing's 
            // Consecutive Optional Parameter bug. :(
            var packageDisplayRoute = routes.MapRoute(
                RouteName.DisplayPackage,
                "packages/{id}/{version}",
                MVC.Packages.DisplayPackage().AddRouteValue("version", UrlParameter.Optional),
                null /*defaults*/,
                new { version = new VersionRouteConstraint() });

            var packageVersionActionRoute = routes.MapRoute(
                RouteName.PackageVersionAction,
                "packages/{id}/{version}/{action}",
                new { controller = MVC.Packages.Name },
                new { version = new VersionRouteConstraint() });

            var packageActionRoute = routes.MapRoute(
                RouteName.PackageAction,
                "packages/{id}/{action}",
                new { controller = MVC.Packages.Name });

            routes.MapRoute(
                RouteName.Authentication,
                "users/account/{action}",
                new { controller = MVC.Authentication.Name });

            routes.MapRoute(
                RouteName.Profile,
                "profiles/{username}",
                MVC.Users.Profiles());

            routes.MapRoute(
                RouteName.PasswordReset,
                "account/{action}/{username}/{token}",
                MVC.Users.ResetPassword());

            routes.MapRoute(
                RouteName.Account,
                "account/{action}",
                MVC.Users.Account());

            routes.MapRoute(
                RouteName.PushPackageApi,
                "PackageFiles/{apiKey}/nupkg",
                MVC.Api.CreatePackage());

            routes.MapRoute(
                RouteName.PublishPackageApi,
                "PublishedPackages/Publish",
                MVC.Api.PublishPackage());

            routes.MapRoute(
                RouteName.DeletePackageApi,
                "Packages/{apiKey}/{id}/{version}",
                MVC.Api.DeletePackage());

            routes.MapServiceRoute(
                RouteName.V1ApiFeed,
                "api/feeds/v1",
                typeof(V1Feed));

            routes.MapServiceRoute(
                RouteName.V2ApiFeed,
                "api/feeds/v2",
                typeof(V2Feed));

            routes.MapServiceRoute(
                RouteName.ApiFeed,
                "api/feeds",
                typeof(V2Feed));

            // Redirected Legacy Routes

            routes.Redirect(
                r => r.MapRoute(
                    "ReportAbuse",
                    "Package/ReportAbuse/{id}/{version}",
                    MVC.Packages.ReportAbuse()),
                permanent: true).To(packageVersionActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "PackageActions",
                    "Package/{action}/{id}",
                    MVC.Packages.ContactOwners(),
                    null /*defaults*/,
                    // This next bit looks bad, but it's not. It will never change because 
                    // it's mapping the legacy routes to the new better routes.
                    new { action = "ContactOwners|ManagePackageOwners" }),
                permanent: true).To(packageActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "PublishPackage",
                    "Package/New/{id}/{version}",
                    MVC.Packages.PublishPackage()),
                permanent: true).To(packageVersionActionRoute);

            // TODO: this route looks broken as there is no EditPackage action
            //routes.Redirect(
            //    r => r.MapRoute(
            //        "EditPackage",
            //        "Package/Edit/{id}/{version}",
            //        new { controller = PackagesController.Name, action = "EditPackage" }),
            //    permanent: true).To(packageVersionActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.ListPackages,
                    "List/Packages",
                    MVC.Packages.ListPackages()),
                permanent: true).To(packageListRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.DisplayPackage,
                    "List/Packages/{id}/{version}",
                    MVC.Packages.DisplayPackage().AddRouteValue("version", UrlParameter.Optional)),
                permanent: true).To(packageDisplayRoute);
        }
        /// <summary>
        /// Registers the routes.
        /// </summary>
        /// <param name="routes">The routes.</param>
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("virto/services/{MyJob}.svc/{*pathInfo}");
            routes.IgnoreRoute("virto/dataservices/{MyJob}.svc/{*pathInfo}");
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
            routes.IgnoreRoute(".html");

            //Ignore all calls to bundles
            routes.IgnoreRoute("bundles/{*pathInfo}");
            //Ignore all calls to areas (Areas supposed to serve own routes)
            routes.IgnoreRoute("areas/{*pathInfo}");

            //This makes sure index.html (or any other deafult document is opened for empty url
            routes.IgnoreRoute("");

            routes.MapRoute(
                "FailWhale",
                "FailWhale/{action}/{id}", new { controller = "Error", action = "FailWhale", id = UrlParameter.Optional });

            routes.MapRoute(
                "Assets",
                "asset/{*path}",
                new { controller = "Asset", action = "Index", path = UrlParameter.Optional });

            var itemRoute = new NormalizeRoute(
                new ItemRoute(Constants.ItemRoute,
                              new RouteValueDictionary
            {
                { "controller", "Catalog" },
                { "action", "DisplayItem" },
                { Constants.Language, UrlParameter.Optional }
            },
                              new RouteValueDictionary
            {
                { Constants.Language, new LanguageRouteConstraint() },
                { Constants.Store, new StoreRouteConstraint() },
                { Constants.Category, new CategoryRouteConstraint() },
                { Constants.Item, new ItemRouteConstraint() }
            },
                              new RouteValueDictionary {
                { "namespaces", new[] { "VirtoCommerce.Web.Controllers" } }
            },
                              new MvcRouteHandler()));

            var categoryRoute = new NormalizeRoute(
                new CategoryRoute(Constants.CategoryRoute,
                                  new RouteValueDictionary
            {
                { "controller", "Catalog" },
                { "action", "Display" },
                { Constants.Language, UrlParameter.Optional }
            },
                                  new RouteValueDictionary
            {
                { Constants.Language, new LanguageRouteConstraint() },
                { Constants.Store, new StoreRouteConstraint() },
                { Constants.Category, new CategoryRouteConstraint() }
            },
                                  new RouteValueDictionary {
                { "namespaces", new[] { "VirtoCommerce.Web.Controllers" } }
            },
                                  new MvcRouteHandler()));

            var storeRoute = new NormalizeRoute(
                new StoreRoute(Constants.StoreRoute,
                               new RouteValueDictionary
            {
                { "controller", "Home" },
                { "action", "Index" }
            },
                               new RouteValueDictionary
            {
                { Constants.Language, new LanguageRouteConstraint() },
                { Constants.Store, new StoreRouteConstraint() }
            },
                               new RouteValueDictionary {
                { "namespaces", new[] { "VirtoCommerce.Web.Controllers" } }
            },
                               new MvcRouteHandler()));

            routes.Add("Item", itemRoute);
            routes.Add("Category", categoryRoute);
            routes.Add("Store", storeRoute);

            //Legacy redirects
            routes.Redirect(r => r.MapRoute("old_Category", string.Format("c/{{{0}}}", Constants.Category))).To(categoryRoute,
                                                                                                                x =>
            {
                //Expect to receive category code
                if (x.RouteData.Values.ContainsKey(Constants.Category))
                {
                    var category = CatalogHelper.CatalogClient.GetCategory(x.RouteData.Values[Constants.Category].ToString());
                    if (category != null)
                    {
                        return(new RouteValueDictionary {
                            { Constants.Category, category.CategoryId }
                        });
                    }
                }
                return(null);
            });
            routes.Redirect(r => r.MapRoute("old_Item", string.Format("p/{{{0}}}", Constants.Item))).To(itemRoute,
                                                                                                        x =>
            {
                //Resolve item category dynamically
                //Expect to receive item code
                if (x.RouteData.Values.ContainsKey(Constants.Item))
                {
                    var item = CatalogHelper.CatalogClient.GetItemByCode(x.RouteData.Values[Constants.Item].ToString(), StoreHelper.CustomerSession.CatalogId);
                    if (item != null)
                    {
                        return(new RouteValueDictionary {
                            { Constants.Category, item.GetItemCategoryRouteValue() }
                        });
                    }
                }
                return(null);
            });

            var defaultRoute = new NormalizeRoute(new Route(string.Format("{{{0}}}/{{controller}}/{{action}}/{{id}}", Constants.Language),
                                                            new RouteValueDictionary {
                { "id", UrlParameter.Optional }, { "action", "Index" }
            },
                                                            new RouteValueDictionary {
                { Constants.Language, new LanguageRouteConstraint() }
            },
                                                            new RouteValueDictionary {
                { "namespaces", new[] { "VirtoCommerce.Web.Controllers" } }
            },
                                                            new MvcRouteHandler()));

            //Other actions
            routes.Add("Default", defaultRoute);

            //Needed for some post requests
            routes.MapRoute(
                "Default_Fallback",           // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new
            {
                action = "Index",
                id     = UrlParameter.Optional
            },     // Parameter defaults
                new[] { "VirtoCommerce.Web.Controllers" });
        }
Example #25
0
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.MapRoute(
                RouteName.Home,
                "",
                new { controller = MVC.Pages.Name, action = "Home" }); // T4MVC doesn't work with Async Action

            routes.MapRoute(
                RouteName.Error500,
                "errors/500",
                MVC.Errors.InternalError());

            routes.MapRoute(
                RouteName.Error404,
                "errors/404",
                MVC.Errors.NotFound());

            routes.MapRoute(
                RouteName.StatisticsHome,
                "stats",
                new { controller = MVC.Statistics.Name, action = "Index" });

            routes.MapRoute(
                RouteName.Stats,
                "stats/totals",
                MVC.Statistics.Totals());

            routes.MapRoute(
                RouteName.StatisticsPackages,
                "stats/packages",
                new { controller = MVC.Statistics.Name, action = "Packages" });

            routes.MapRoute(
                RouteName.StatisticsPackageVersions,
                "stats/packageversions",
                new { controller = MVC.Statistics.Name, action = "PackageVersions" });

            routes.MapRoute(
                RouteName.StatisticsPackageDownloadsDetail,
                "stats/packages/{id}/{version}",
                new { controller = MVC.Statistics.Name, action = "PackageDownloadsDetail" });

            routes.MapRoute(
                RouteName.StatisticsPackageDownloadsByVersion,
                "stats/packages/{id}",
                new { controller = MVC.Statistics.Name, action = "PackageDownloadsByVersion" });

            routes.Add(new JsonRoute("json/{controller}"));

            routes.MapRoute(
                RouteName.Policies,
                "policies/{action}",
                new { controller = MVC.Pages.Name });

            routes.MapRoute(
                RouteName.Pages,
                "pages/{pageName}",
                new { controller = MVC.Pages.Name, action = "Page" });

            var packageListRoute = routes.MapRoute(
                RouteName.ListPackages,
                "packages",
                MVC.Packages.ListPackages());

            var uploadPackageRoute = routes.MapRoute(
                RouteName.UploadPackage,
                "packages/upload",
                new { controller = MVC.Packages.Name, action = "UploadPackage" });

            routes.MapRoute(
                RouteName.UploadPackageProgress,
                "packages/upload-progress",
                MVC.Packages.UploadPackageProgress());

            routes.MapRoute(
                RouteName.VerifyPackage,
                "packages/verify-upload",
                new { controller = MVC.Packages.Name, action = "VerifyPackage" });

            routes.MapRoute(
                RouteName.CancelUpload,
                "packages/cancel-upload",
                new { controller = MVC.Packages.Name, action = "CancelUpload" });

            routes.MapRoute(
                RouteName.PackageOwnerConfirmation,
                "packages/{id}/owners/{username}/confirm/{token}",
                new { controller = MVC.Packages.Name, action = "ConfirmOwner" });

            // We need the following two routes (rather than just one) due to Routing's
            // Consecutive Optional Parameter bug. :(
            var packageDisplayRoute = routes.MapRoute(
                RouteName.DisplayPackage,
                "packages/{id}/{version}",
                MVC.Packages.DisplayPackage().AddRouteValue("version", UrlParameter.Optional),
                null /*defaults*/,
                new { version = new VersionRouteConstraint() });

            routes.MapRoute(
                RouteName.PackageEnableLicenseReport,
                "packages/{id}/{version}/EnableLicenseReport",
                new { controller = MVC.Packages.Name, action = "SetLicenseReportVisibility", visible = true },
                new { version = new VersionRouteConstraint() });

            routes.MapRoute(
                RouteName.PackageDisableLicenseReport,
                "packages/{id}/{version}/DisableLicenseReport",
                new { controller = MVC.Packages.Name, action = "SetLicenseReportVisibility", visible = false },
                new { version = new VersionRouteConstraint() });

            var packageVersionActionRoute = routes.MapRoute(
                RouteName.PackageVersionAction,
                "packages/{id}/{version}/{action}",
                new { controller = MVC.Packages.Name },
                new { version = new VersionRouteConstraint() });

            var packageActionRoute = routes.MapRoute(
                RouteName.PackageAction,
                "packages/{id}/{action}",
                new { controller = MVC.Packages.Name });

            var confirmationRequiredRoute = routes.MapRoute(
                "ConfirmationRequired",
                "account/ConfirmationRequired",
                MVC.Users.ConfirmationRequired());

            //Redirecting v1 Confirmation Route
            routes.Redirect(
                r => r.MapRoute(
                    "v1Confirmation",
                    "Users/Account/ChallengeEmail")).To(confirmationRequiredRoute);

            routes.MapRoute(
                RouteName.ExternalAuthenticationCallback,
                "users/account/authenticate/return",
                new { controller = MVC.Authentication.Name, action = "LinkExternalAccount" });

            routes.MapRoute(
                RouteName.ExternalAuthentication,
                "users/account/authenticate/{provider}",
                new { controller = MVC.Authentication.Name, action = MVC.Authentication.ActionNames.Authenticate });

            routes.MapRoute(
                RouteName.Authentication,
                "users/account/{action}",
                new { controller = MVC.Authentication.Name });

            routes.MapRoute(
                RouteName.Profile,
                "profiles/{username}",
                MVC.Users.Profiles());

            routes.MapRoute(
                RouteName.LegacyRegister,
                "account/register",
                new { controller = MVC.Authentication.Name, action = "Register" });

            routes.MapRoute(
                RouteName.RemovePassword,
                "account/RemoveCredential/password",
                new { controller = MVC.Users.Name, action = "RemovePassword" });

            routes.MapRoute(
                RouteName.RemoveCredential,
                "account/RemoveCredential/{credentialType}",
                new { controller = MVC.Users.Name, action = "RemoveCredential" });

            routes.MapRoute(
                RouteName.PasswordReset,
                "account/forgotpassword/{username}/{token}",
                MVC.Users.ResetPassword(forgot: true));

            routes.MapRoute(
                RouteName.PasswordSet,
                "account/setpassword/{username}/{token}",
                MVC.Users.ResetPassword(forgot: false));

            routes.MapRoute(
                RouteName.ConfirmAccount,
                "account/confirm/{username}/{token}",
                new { controller = MVC.Users.Name, action = "Confirm" });

            routes.MapRoute(
                RouteName.SubscribeToEmails,
                "account/subscribe",
                MVC.Users.ChangeEmailSubscription(true));

            routes.MapRoute(
                RouteName.UnsubscribeFromEmails,
                "account/unsubscribe",
                MVC.Users.ChangeEmailSubscription(false));

            routes.MapRoute(
                RouteName.Account,
                "account/{action}",
                MVC.Users.Account());

            routes.MapRoute(
                RouteName.CuratedFeed,
                "curated-feeds/{name}",
                new { controller = CuratedFeedsController.ControllerName, action = "CuratedFeed" });

            routes.MapRoute(
                RouteName.CuratedFeedListPackages,
                "curated-feeds/{curatedFeedName}/packages",
                MVC.CuratedFeeds.ListPackages());

            routes.MapRoute(
                RouteName.CreateCuratedPackageForm,
                "forms/add-package-to-curated-feed",
                new { controller = CuratedPackagesController.ControllerName, action = "CreateCuratedPackageForm" });

            routes.MapRoute(
                RouteName.CuratedPackagesReIndex,
                "curated-feeds/{curatedFeedName}/reindex",
                new { controller = CuratedPackagesController.ControllerName, action = "ReIndex" });

            routes.MapRoute(
                RouteName.CuratedPackage,
                "curated-feeds/{curatedFeedName}/curated-packages/{curatedPackageId}",
                new { controller = CuratedPackagesController.ControllerName, action = "CuratedPackage" });

            routes.MapRoute(
                RouteName.CuratedPackages,
                "curated-feeds/{curatedFeedName}/curated-packages",
                new { controller = CuratedPackagesController.ControllerName, action = "CuratedPackages" });

            // TODO : Most of the routes are essentially of the format api/v{x}/*. We should refactor the code to vary them by the version.
            // V1 Routes
            // If the push url is /api/v1 then NuGet.Core would ping the path to resolve redirection.
            routes.MapRoute(
                "v1" + RouteName.VerifyPackageKey,
                "api/v1/verifykey/{id}/{version}",
                MVC.Api.VerifyPackageKey(),
                defaults: new { id = UrlParameter.Optional, version = UrlParameter.Optional });

            var downloadRoute = routes.MapRoute(
                "v1" + RouteName.DownloadPackage,
                "api/v1/package/{id}/{version}",
                defaults: new { controller = MVC.Api.Name, action = "GetPackageApi", version = UrlParameter.Optional },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                "v1" + RouteName.PushPackageApi,
                "v1/PackageFiles/{apiKey}/nupkg",
                defaults: new { controller = MVC.Api.Name, action = "PushPackageApi" },
                constraints: new { httpMethod = new HttpMethodConstraint("POST") });

            routes.MapRoute(
                "v1" + RouteName.DeletePackageApi,
                "v1/Packages/{apiKey}/{id}/{version}",
                MVC.Api.DeletePackage());

            routes.MapRoute(
                "v1" + RouteName.PublishPackageApi,
                "v1/PublishedPackages/Publish",
                MVC.Api.PublishPackage());

            // V2 routes
            routes.MapRoute(
                "v2" + RouteName.VerifyPackageKey,
                "api/v2/verifykey/{id}/{version}",
                MVC.Api.VerifyPackageKey(),
                defaults: new { id = UrlParameter.Optional, version = UrlParameter.Optional });

            routes.MapRoute(
                "v2CuratedFeeds" + RouteName.DownloadPackage,
                "api/v2/curated-feeds/package/{id}/{version}",
                defaults: new { controller = MVC.Api.Name, action = "GetPackageApi", version = UrlParameter.Optional },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                "v2" + RouteName.DownloadPackage,
                "api/v2/package/{id}/{version}",
                defaults: new { controller = MVC.Api.Name, action = "GetPackageApi", version = UrlParameter.Optional },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                "v2" + RouteName.PushPackageApi,
                "api/v2/package",
                defaults: new { controller = MVC.Api.Name, action = "PushPackageApi" },
                constraints: new { httpMethod = new HttpMethodConstraint("PUT") });

            routes.MapRoute(
                "v2" + RouteName.DeletePackageApi,
                "api/v2/package/{id}/{version}",
                MVC.Api.DeletePackage(),
                defaults: null,
                constraints: new { httpMethod = new HttpMethodConstraint("DELETE") });

            routes.MapRoute(
                "v2" + RouteName.PublishPackageApi,
                "api/v2/package/{id}/{version}",
                MVC.Api.PublishPackage(),
                defaults: null,
                constraints: new { httpMethod = new HttpMethodConstraint("POST") });

            routes.MapRoute(
                "v2PackageIds",
                "api/v2/package-ids",
                MVC.Api.GetPackageIds());

            routes.MapRoute(
                "v2PackageVersions",
                "api/v2/package-versions/{id}",
                MVC.Api.GetPackageVersions());

            routes.MapRoute(
                RouteName.StatisticsDownloadsApi,
                "api/v2/stats/downloads/last6weeks",
                defaults: new { controller = MVC.Api.Name, action = "StatisticsDownloadsApi" },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                RouteName.ServiceAlert,
                "api/v2/service-alert",
                defaults: new { controller = MVC.Api.Name, action = "ServiceAlert" },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                RouteName.DownloadNuGetExe,
                "nuget.exe",
                new { controller = MVC.Api.Name, action = "GetNuGetExeApi" });

            // Redirected Legacy Routes

            routes.Redirect(
                r => r.MapRoute(
                    "ReportAbuse",
                    "Package/ReportAbuse/{id}/{version}",
                    MVC.Packages.ReportAbuse()),
                permanent: true).To(packageVersionActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "PackageActions",
                    "Package/{action}/{id}",
                    MVC.Packages.ContactOwners(),
                    null /*defaults*/,
                    // This next bit looks bad, but it's not. It will never change because
                    // it's mapping the legacy routes to the new better routes.
                    new { action = "ContactOwners|ManagePackageOwners" }),
                permanent: true).To(packageActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.ListPackages,
                    "List/Packages",
                    MVC.Packages.ListPackages()),
                permanent: true).To(packageListRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.DisplayPackage,
                    "List/Packages/{id}/{version}",
                    MVC.Packages.DisplayPackage().AddRouteValue("version", UrlParameter.Optional)),
                permanent: true).To(packageDisplayRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.NewSubmission,
                    "Contribute/NewSubmission",
                    new { controller = MVC.Packages.Name, action = "UploadPackage" }),
                permanent: true).To(uploadPackageRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "LegacyDownloadRoute",
                    "v1/Package/Download/{id}/{version}",
                    new { controller = MVC.Api.Name, action = "GetPackageApi", version = UrlParameter.Optional }),
                permanent: true).To(downloadRoute);

            routes.MapRoute(
                name: "InternalApi",
                url: "api/internal/{action}",
                defaults: new { controller = "Internal" });
        }
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.MapRoute(
                RouteName.Home,
                "",
                MVC.Pages.Home());

            routes.MapRoute(
                RouteName.StatisticsHome,
                "stats",
                new { controller = MVC.Statistics.Name, action = "Index" });

            routes.MapRoute(
                RouteName.Stats,
                "stats/totals",
                MVC.Statistics.Totals());

            routes.MapRoute(
                RouteName.StatisticsPackages,
                "stats/packages",
                new { controller = MVC.Statistics.Name, action = "Packages" });

            routes.MapRoute(
                RouteName.StatisticsPackageVersions,
                "stats/packageversions",
                new { controller = MVC.Statistics.Name, action = "PackageVersions" });

            routes.MapRoute(
                RouteName.StatisticsPackageDownloadsDetail,
                "stats/packages/{id}/{version}",
                new { controller = MVC.Statistics.Name, action = "PackageDownloadsDetail" });

            routes.MapRoute(
                RouteName.StatisticsPackageDownloadsByVersion,
                "stats/packages/{id}",
                new { controller = MVC.Statistics.Name, action = "PackageDownloadsByVersion" });

            routes.Add(new JsonRoute("json/{controller}"));

            routes.MapRoute(
                RouteName.Policies,
                "policies/{action}",
                MVC.Pages.Terms());

            var packageListRoute = routes.MapRoute(
                RouteName.ListPackages,
                "packages",
                MVC.Packages.ListPackages());

            var uploadPackageRoute = routes.MapRoute(
                RouteName.UploadPackage,
                "packages/upload",
                new { controller = MVC.Packages.Name, action = "UploadPackage" });

            routes.MapRoute(
                RouteName.UploadPackageProgress,
                "packages/upload-progress",
                MVC.Packages.UploadPackageProgress());

            routes.MapRoute(
                RouteName.VerifyPackage,
                "packages/verify-upload",
                new { controller = MVC.Packages.Name, action = "VerifyPackage" });

            routes.MapRoute(
                RouteName.CancelUpload,
                "packages/cancel-upload",
                new { controller = MVC.Packages.Name, action = "CancelUpload" });

            routes.MapRoute(
                RouteName.PackageOwnerConfirmation,
                "packages/{id}/owners/{username}/confirm/{token}",
                new { controller = MVC.Packages.Name, action = "ConfirmOwner" });

            // We need the following two routes (rather than just one) due to Routing's
            // Consecutive Optional Parameter bug. :(
            var packageDisplayRoute = routes.MapRoute(
                RouteName.DisplayPackage,
                "packages/{id}/{version}",
                MVC.Packages.DisplayPackage().AddRouteValue("version", UrlParameter.Optional),
                null /*defaults*/,
                new { version = new VersionRouteConstraint() });

            var packageVersionActionRoute = routes.MapRoute(
                RouteName.PackageVersionAction,
                "packages/{id}/{version}/{action}",
                new { controller = MVC.Packages.Name },
                new { version = new VersionRouteConstraint() });

            var packageActionRoute = routes.MapRoute(
                RouteName.PackageAction,
                "packages/{id}/{action}",
                new { controller = MVC.Packages.Name });

            var resendRoute = routes.MapRoute(
                "ResendConfirmation",
                "account/ResendConfirmation",
                MVC.Users.ResendConfirmation());

            //Redirecting v1 Confirmation Route
            routes.Redirect(
                r => r.MapRoute(
                    "v1Confirmation",
                    "Users/Account/ChallengeEmail")).To(resendRoute);

            routes.MapRoute(
                RouteName.Authentication,
                "users/account/{action}",
                new { controller = MVC.Authentication.Name });

            routes.MapRoute(
                RouteName.Profile,
                "profiles/{username}",
                MVC.Users.Profiles());

            routes.MapRoute(
                RouteName.PasswordReset,
                "account/{action}/{username}/{token}",
                MVC.Users.ResetPassword());

            routes.MapRoute(
                RouteName.Account,
                "account/{action}",
                MVC.Users.Account());

            routes.MapRoute(
                RouteName.CuratedFeed,
                "curated-feeds/{name}",
                new { controller = CuratedFeedsController.ControllerName, action = "CuratedFeed" });

            routes.MapRoute(
                RouteName.CuratedFeedListPackages,
                "curated-feeds/{curatedFeedName}/packages",
                MVC.CuratedFeeds.ListPackages());

            routes.MapRoute(
                RouteName.CreateCuratedPackageForm,
                "forms/add-package-to-curated-feed",
                new { controller = CuratedPackagesController.ControllerName, action = "CreateCuratedPackageForm" });

            routes.MapRoute(
                RouteName.CuratedPackage,
                "curated-feeds/{curatedFeedName}/curated-packages/{curatedPackageId}",
                new { controller = CuratedPackagesController.ControllerName, action = "CuratedPackage" });

            routes.MapRoute(
                RouteName.CuratedPackages,
                "curated-feeds/{curatedFeedName}/curated-packages",
                new { controller = CuratedPackagesController.ControllerName, action = "CuratedPackages" });

            // TODO : Most of the routes are essentially of the format api/v{x}/*. We should refactor the code to vary them by the version.
            // V1 Routes
            // If the push url is /api/v1 then NuGet.Core would ping the path to resolve redirection.
            routes.MapRoute(
                "v1" + RouteName.VerifyPackageKey,
                "api/v1/verifykey/{id}/{version}",
                MVC.Api.VerifyPackageKey(),
                defaults: new { id = UrlParameter.Optional, version = UrlParameter.Optional });

            var downloadRoute = routes.MapRoute(
                "v1" + RouteName.DownloadPackage,
                "api/v1/package/{id}/{version}",
                defaults: new { controller = MVC.Api.Name, action = "GetPackageApi", version = UrlParameter.Optional },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                "v1" + RouteName.PushPackageApi,
                "v1/PackageFiles/{apiKey}/nupkg",
                defaults: new { controller = MVC.Api.Name, action = "PushPackageApi" },
                constraints: new { httpMethod = new HttpMethodConstraint("POST") });

            routes.MapRoute(
                "v1" + RouteName.DeletePackageApi,
                "v1/Packages/{apiKey}/{id}/{version}",
                MVC.Api.DeletePackage());

            routes.MapRoute(
                "v1" + RouteName.PublishPackageApi,
                "v1/PublishedPackages/Publish",
                MVC.Api.PublishPackage());

            // V2 routes
            routes.MapRoute(
                "v2" + RouteName.VerifyPackageKey,
                "api/v2/verifykey/{id}/{version}",
                MVC.Api.VerifyPackageKey(),
                defaults: new { id = UrlParameter.Optional, version = UrlParameter.Optional });

            routes.MapRoute(
                "v2CuratedFeeds" + RouteName.DownloadPackage,
                "api/v2/curated-feeds/package/{id}/{version}",
                defaults: new { controller = MVC.Api.Name, action = "GetPackageApi", version = UrlParameter.Optional },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                "v2" + RouteName.DownloadPackage,
                "api/v2/package/{id}/{version}",
                defaults: new { controller = MVC.Api.Name, action = "GetPackageApi", version = UrlParameter.Optional },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                "v2" + RouteName.PushPackageApi,
                "api/v2/package",
                defaults: new { controller = MVC.Api.Name, action = "PushPackageApi" },
                constraints: new { httpMethod = new HttpMethodConstraint("PUT") });

            routes.MapRoute(
                "v2" + RouteName.DeletePackageApi,
                "api/v2/package/{id}/{version}",
                MVC.Api.DeletePackage(),
                defaults: null,
                constraints: new { httpMethod = new HttpMethodConstraint("DELETE") });

            routes.MapRoute(
                "v2" + RouteName.PublishPackageApi,
                "api/v2/package/{id}/{version}",
                MVC.Api.PublishPackage(),
                defaults: null,
                constraints: new { httpMethod = new HttpMethodConstraint("POST") });

            routes.MapRoute(
                "v2PackageIds",
                "api/v2/package-ids",
                MVC.Api.GetPackageIds());

            routes.MapRoute(
                "v2PackageVersions",
                "api/v2/package-versions/{id}",
                MVC.Api.GetPackageVersions());

            routes.MapRoute(
                RouteName.StatisticsDownloadsApi,
                "api/v2/stats/downloads/last6weeks",
                defaults: new { controller = MVC.Api.Name, action = "StatisticsDownloadsApi" },
                constraints: new { httpMethod = new HttpMethodConstraint("GET") });

            routes.MapRoute(
                RouteName.DownloadNuGetExe,
                "nuget.exe",
                new { controller = MVC.Api.Name, action = "GetNuGetExeApi" });

            // Redirected Legacy Routes

            routes.Redirect(
                r => r.MapRoute(
                    "ReportAbuse",
                    "Package/ReportAbuse/{id}/{version}",
                    MVC.Packages.ReportAbuse()),
                permanent: true).To(packageVersionActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "PackageActions",
                    "Package/{action}/{id}",
                    MVC.Packages.ContactOwners(),
                    null /*defaults*/,
                    // This next bit looks bad, but it's not. It will never change because
                    // it's mapping the legacy routes to the new better routes.
                    new { action = "ContactOwners|ManagePackageOwners" }),
                permanent: true).To(packageActionRoute);


            // TODO: this route looks broken as there is no EditPackage action
            //routes.Redirect(
            //    r => r.MapRoute(
            //        "EditPackage",
            //        "Package/Edit/{id}/{version}",
            //        new { controller = PackagesController.ControllerName, action = "EditPackage" }),
            //    permanent: true).To(packageVersionActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.ListPackages,
                    "List/Packages",
                    MVC.Packages.ListPackages()),
                permanent: true).To(packageListRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.DisplayPackage,
                    "List/Packages/{id}/{version}",
                    MVC.Packages.DisplayPackage().AddRouteValue("version", UrlParameter.Optional)),
                permanent: true).To(packageDisplayRoute);

            routes.Redirect(
                r => r.MapRoute(
                    RouteName.NewSubmission,
                    "Contribute/NewSubmission",
                    new { controller = MVC.Packages.Name, action = "UploadPackage" }),
                permanent: true).To(uploadPackageRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "LegacyDownloadRoute",
                    "v1/Package/Download/{id}/{version}",
                    new { controller = MVC.Api.Name, action = "GetPackageApi", version = UrlParameter.Optional }),
                permanent: true).To(downloadRoute);
        }
Example #27
0
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{*favicon}", new { favicon = @"(.*/)?favicon.ico(/.*)?" });
            routes.IgnoreRoute("{*Content}", new { imgs = @"(.*/)?Content(/.*)?" });
            routes.IgnoreRoute("{*Scripts}", new { scripts = @"(.*/)?Scripts(/.*)?" });

            routes.MapRoute(RouteName.Home, "", MVC.Pages.Home());

            routes.MapRouteSeo(
                RouteName.InstallerBatchFile, "installChocolatey.cmd", new
            {
                controller = "Pages",
                Action     = "InstallerBatchFile"
            });

            routes.MapRouteSeo(
                RouteName.Features, "features", new
            {
                controller = "Pages",
                Action     = "Features"
            });

            routes.MapRouteSeo(
                RouteName.About, "about", new
            {
                controller = "Pages",
                Action     = "About"
            });

            routes.MapRouteSeo(
                RouteName.Notice, "notice", new
            {
                controller = "Pages",
                Action     = "Notice"
            });

            var pricingRoute = routes.MapRoute(
                RouteName.Pricing, "pricing", new
            {
                controller = "Pages",
                Action     = "Pricing"
            });

            routes.MapRoute(
                RouteName.Discount, "discount", new
            {
                controller = "Pages",
                Action     = "Discount"
            });

            routes.MapRoute(
                RouteName.Evaluation, "evaluation", new
            {
                controller = "Pages",
                Action     = "Evaluation"
            });

            routes.MapRouteSeo(
                RouteName.Compare, "compare", new
            {
                controller = "Pages",
                Action     = "Compare"
            });

            routes.MapRouteSeo(
                RouteName.Install, "install", new
            {
                controller = "Pages",
                Action     = "Install"
            });

            routes.MapRouteSeo(
                RouteName.Sitemap, "sitemap", new
            {
                controller = "Pages",
                Action     = "Sitemap"
            });

            routes.MapRouteSeo(
                RouteName.Community, "community", new
            {
                controller = "Pages",
                Action     = "Community"
            });

            var productsRoute = routes.MapRoute(
                RouteName.Products, "products", new
            {
                controller = "Pages",
                Action     = "Products"
            });

            routes.Redirect(r => r.MapRoute(RouteName.Business, "business")).To(productsRoute);

            routes.MapRouteSeo(
                RouteName.WhyChocolatey, "why-chocolatey", new
            {
                controller = "Pages",
                Action     = "WhyChocolatey"
            });

            routes.MapRouteSeo(
                RouteName.UseCases, "use-cases", new
            {
                controller = "Pages",
                Action     = "UseCases"
            });

            routes.MapRouteSeo(
                RouteName.HowChocolateyWorks, "how-chocolatey-works", new
            {
                controller = "Pages",
                Action     = "HowChocolateyWorks"
            });

            routes.MapRouteSeo(
                RouteName.Careers, "careers", new
            {
                controller = "Pages",
                Action     = "Careers"
            });

            routes.MapRouteSeo(
                RouteName.FAQ, "faq", new
            {
                controller = "Pages",
                Action     = "FAQ"
            });

            routes.MapRouteSeo(
                RouteName.Kickstarter, "kickstarter", new
            {
                controller = "Pages",
                Action     = "Kickstarter"
            });

            routes.MapRouteSeo(
                RouteName.Terms, "terms", new
            {
                controller = "Pages",
                Action     = "Terms"
            });

            routes.MapRouteSeo(
                RouteName.Privacy, "privacy", new
            {
                controller = "Pages",
                Action     = "Privacy"
            });

            routes.MapRouteSeo(
                RouteName.MediaKit, "media-kit", new
            {
                controller = "Pages",
                Action     = "MediaKit"
            });

            routes.MapRouteSeo(
                RouteName.Company, "company", new
            {
                controller = "Pages",
                Action     = "Company"
            });

            routes.MapRouteSeo(
                RouteName.ContactTrial, "contact/trial", new
            {
                controller = "Pages",
                Action     = "ContactTrial"
            });

            routes.MapRouteSeo(
                RouteName.ContactUs, "contact", new
            {
                controller = "Pages",
                Action     = "ContactUs"
            });

            routes.MapRouteSeo(
                RouteName.ContactGeneral, "contact/general", new
            {
                controller = "Pages",
                Action     = "ContactGeneral"
            });

            routes.MapRouteSeo(
                RouteName.ContactDiscount, "contact/student-discount", new
            {
                controller = "Pages",
                Action     = "ContactDiscount"
            });

            routes.MapRouteSeo(
                RouteName.ContactPartner, "contact/partner", new
            {
                controller = "Pages",
                Action     = "ContactPartner"
            });

            routes.MapRouteSeo(
                RouteName.ContactSales, "contact/sales", new
            {
                controller = "Pages",
                Action     = "ContactSales"
            });

            routes.MapRouteSeo(
                RouteName.ContactSalesOther, "contact/sales-for-another-organization", new
            {
                controller = "Pages",
                Action     = "ContactSalesOther"
            });

            routes.MapRouteSeo(
                RouteName.ContactBlocked, "contact/blocked-ip-address", new
            {
                controller = "Pages",
                Action     = "ContactBlocked"
            });

            routes.MapRouteSeo(
                RouteName.ContactQuickDeployment, "contact/quick-deployment", new
            {
                controller = "Pages",
                Action     = "ContactQuickDeployment"
            });

            routes.MapRouteSeo(
                RouteName.Support, "support", new
            {
                controller = "Pages",
                Action     = "Support"
            });

            routes.MapRouteSeo(
                RouteName.ReportIssue, "bugs", new
            {
                controller = "Pages",
                Action     = "ReportIssue"
            });

            routes.MapRouteSeo(
                RouteName.Press, "press", new
            {
                controller = "Pages",
                Action     = "Press"
            });

            routes.MapRouteSeo(
                RouteName.Partner, "partner", new
            {
                controller = "Pages",
                Action     = "Partner"
            });

            routes.MapRouteSeo(
                RouteName.Security, "security", new
            {
                controller = "Pages",
                Action     = "Security"
            });

            routes.MapRouteSeo(
                RouteName.Covid19, "covid-19", new
            {
                controller = "Pages",
                Action     = "Covid19"
            });

            routes.MapRouteSeo(
                RouteName.Styleguide,
                "styleguide/{styleguideName}",
                new { controller = "Styleguide", action = "Styleguide", styleguideName = "home" }
                );

            routes.MapRouteSeo(
                RouteName.BlogHome,
                "blog/",
                new { controller = "Blog", action = "Index" }
                );

            routes.MapRouteSeo(
                RouteName.BlogArticle,
                "blog/{articleName}",
                new { controller = "Blog", action = "Article" }
                );

            routes.MapRouteSeo(
                RouteName.Resources,
                "resources/{resourceType}",
                new { controller = "Resource", action = "Resources", resourceType = "home" }
                );

            var resourceNameRoute = new Route("resources/{resourceType}/{resourceName}", new RouteValueDictionary(new { controller = "Resource", action = "ResourceName" }), new HyphenatedRouteHandler());

            // ResourceName redirects
            routes.Redirect(r => r.MapRoute("ManagingWindowsAtFacebookRedirect", "resources/case-studies/managing-windows-at-facebook")).To(resourceNameRoute, new { resourceType = "case-studies", resourceName = "winops-2017-dan-sedlacek-managing-windows-at-facebook" });

            // Add in ResourceName route after redirects have been made
            routes.Add(RouteName.ResourceName, resourceNameRoute);

            var docsRoute = new Route("docs/{docName}", new RouteValueDictionary(new { controller = "Documentation", action = "Documentation", docName = "home" }), new HyphenatedRouteHandler());

            // Documentation redirects
            routes.Redirect(r => r.MapRoute("InstallRedirect", "docs/install")).To(docsRoute, new { docName = "installation" });
            routes.Redirect(r => r.MapRoute("FeaturesShimsRedirect", "docs/features-shims")).To(docsRoute, new { docName = "features-shim" });

            // Add in Docs route after redirects have been made
            routes.Add(RouteName.Docs, docsRoute);

            // temporary redirect
            routes.Redirect(r => r.MapRoute("CentralManagementFeature", "features-chocolatey-central-management")).To(docsRoute, new { docName = "features-chocolatey-central-management" });

            routes.MapRouteSeo(
                RouteName.Courses,
                "courses",
                new { controller = "Courses", action = "Courses" }
                );

            routes.MapRouteSeo(
                RouteName.CourseName,
                "courses/{courseName}/{courseModuleName}",
                new { controller = "Courses", action = "CourseName", courseName = "home", courseModuleName = "home" }
                );

            var solutionsRoute = routes.MapRoute(
                RouteName.Solutions,
                "solutions/{solutionName}",
                new { controller = "Solutions", action = "Solutions", solutionName = "home" }
                );

            routes.Redirect(r => r.MapRoute(RouteName.SelfService, "self-service")).To(solutionsRoute);

            routes.MapRoute(RouteName.Stats, "stats", MVC.Pages.Stats());

            routes.MapRoute(
                "rss feed", "feed.rss", new
            {
                controller = "RSS",
                Action     = "feed.rss"
            });

            routes.MapRoute(
                "blog rss feed", "blog.rss", new
            {
                controller = "Blog",
                Action     = "blog.rss"
            });

            routes.Add(new JsonRoute("json/{controller}"));

            routes.MapRoute(RouteName.Policies, "policies/{action}", MVC.Pages.Terms());

            var packageListRoute = routes.MapRoute(RouteName.ListPackages, "packages", MVC.Packages.ListPackages());

            routes.MapRoute(
                RouteName.NotifyComment, "packages/{packageId}/notify-comment", new
            {
                controller = MVC.Packages.Name,
                action     = "NotifyMaintainersOfAddedComment"
            });

            var uploadPackageRoute = routes.MapRoute(RouteName.UploadPackage, "packages/upload", MVC.Packages.UploadPackage());

            routes.MapRoute(RouteName.VerifyPackage, "packages/verify-upload", MVC.Packages.VerifyPackage());

            routes.MapRoute(RouteName.CancelUpload, "packages/cancel-upload", MVC.Packages.CancelUpload());

            routes.MapRoute(
                RouteName.PackageOwnerConfirmation, "packages/{id}/owners/{username}/confirm/{token}", new
            {
                controller = MVC.Packages.Name,
                action     = "ConfirmOwner"
            });

            // We need the following two routes (rather than just one) due to Routing's
            // Consecutive Optional Parameter bug. :(
            var packageDisplayRoute = routes.MapRoute(
                RouteName.DisplayPackage, "packages/{id}/{version}", MVC.Packages.DisplayPackage().AddRouteValue("version", UrlParameter.Optional), null /*defaults*/, new
            {
                version = new VersionRouteConstraint()
            });

            var packageVersionActionRoute = routes.MapRoute(
                RouteName.PackageVersionAction, "packages/{id}/{version}/{action}", new
            {
                controller = MVC.Packages.Name
            }, new
            {
                version = new VersionRouteConstraint()
            });

            var packageActionRoute = routes.MapRoute(
                RouteName.PackageAction, "packages/{id}/{action}", new
            {
                controller = MVC.Packages.Name
            });

            var resendRoute = routes.MapRoute("ResendConfirmation", "account/ResendConfirmation", MVC.Users.ResendConfirmation());

            //Redirecting v1 Confirmation Route
            routes.Redirect(r => r.MapRoute("v1Confirmation", "Users/Account/ChallengeEmail")).To(resendRoute);

            routes.MapRoute(
                RouteName.Authentication, "users/account/{action}", new
            {
                controller = MVC.Authentication.Name
            });

            routes.MapRoute(RouteName.Profile, "profiles/{username}", MVC.Users.Profiles());

            routes.MapRoute(RouteName.PasswordReset, "account/{action}/{username}/{token}", MVC.Users.ResetPassword());

            routes.MapRoute(RouteName.Account, "account/{action}", MVC.Users.Account());

            routes.MapRoute(
                "site" + RouteName.DownloadPackage, "packages/{id}/{version}/DownloadPackage", MVC.Api.GetPackage(), defaults: new
            {
                version = UrlParameter.Optional
            }, constraints: new
            {
                httpMethod = new HttpMethodConstraint("GET")
            });

            // V1 Routes
            routes.MapRoute("v1Legacy" + RouteName.PushPackageApi, "PackageFiles/{apiKey}/nupkg", MVC.Api.CreatePackagePost());
            routes.MapRoute("v1Legacy" + RouteName.PublishPackageApi, "PublishedPackages/Publish", MVC.Api.PublishPackage());

            // V2 routes
            routes.MapRoute(
                "v2" + RouteName.VerifyPackageKey, "api/v2/verifykey/{id}/{version}", MVC.Api.VerifyPackageKey(), defaults: new
            {
                id      = UrlParameter.Optional,
                version = UrlParameter.Optional
            });

            routes.MapRoute(
                "v2" + RouteName.DownloadPackage, "api/v2/package/{id}/{version}", MVC.Api.GetPackage(), defaults: new
            {
                version = UrlParameter.Optional
            }, constraints: new
            {
                httpMethod = new HttpMethodConstraint("GET")
            });

            routes.MapRoute(
                "v2" + RouteName.PushPackageApi, "api/v2/package", MVC.Api.CreatePackagePut(), defaults: null, constraints: new
            {
                httpMethod = new HttpMethodConstraint("PUT")
            });

            routes.MapRoute(
                "v2" + RouteName.DeletePackageApi, "api/v2/package/{id}/{version}", MVC.Api.DeletePackage(), defaults: null, constraints: new
            {
                httpMethod = new HttpMethodConstraint("DELETE")
            });

            routes.MapRoute(
                "v2" + RouteName.PublishPackageApi, "api/v2/package/{id}/{version}", MVC.Api.PublishPackage(), defaults: null, constraints: new
            {
                httpMethod = new HttpMethodConstraint("POST")
            });

            routes.MapServiceRoute(RouteName.V2ApiSubmittedFeed, "api/v2/submitted", typeof(V2SubmittedFeed));

            routes.MapRoute(
                "v2" + RouteName.TestPackageApi,
                "api/v2/test/{id}/{version}",
                MVC.Api.TestPackage(),
                defaults: null,
                constraints: new
            {
                httpMethod = new HttpMethodConstraint("POST")
            }
                );

            routes.MapRoute(
                "v2" + RouteName.ValidatePackageApi,
                "api/v2/validate/{id}/{version}",
                MVC.Api.ValidatePackage(),
                defaults: null,
                constraints: new
            {
                httpMethod = new HttpMethodConstraint("POST")
            }
                );

            routes.MapRoute(
                "v2" + RouteName.CleanupPackageApi,
                "api/v2/cleanup/{id}/{version}",
                MVC.Api.CleanupPackage(),
                defaults: null,
                constraints: new
            {
                httpMethod = new HttpMethodConstraint("POST")
            }
                );

            routes.MapRoute(
                "v2" + RouteName.DownloadCachePackageApi,
                "api/v2/cache/{id}/{version}",
                MVC.Api.DownloadCachePackage(),
                defaults: null,
                constraints: new
            {
                httpMethod = new HttpMethodConstraint("POST")
            }
                );

            routes.MapRoute(
                "v2" + RouteName.ScanPackageApi,
                "api/v2/scan/{id}/{version}",
                MVC.Api.ScanPackage(),
                defaults: null
                );

            routes.MapRouteSeo(
                "Search", "search", new
            {
                controller = "Packages",
                Action     = "ListPackages"
            });

            routes.MapRoute("v2PackageIds", "api/v2/package-ids", MVC.Api.GetPackageIds());

            routes.MapRoute("v2PackageVersions", "api/v2/package-versions/{id}", MVC.Api.GetPackageVersions());

            routes.MapServiceRoute(RouteName.V2ApiFeed, "api/v2/", typeof(V2Feed));

            // Redirected Legacy Routes

            routes.Redirect(r => r.MapRoute("ReportAbuse", "Package/ReportAbuse/{id}/{version}", MVC.Packages.ReportAbuse()), permanent: true).To(packageVersionActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "PackageActions", "Package/{action}/{id}", MVC.Packages.ContactOwners(), null /*defaults*/, // This next bit looks bad, but it's not. It will never change because
                    // it's mapping the legacy routes to the new better routes.
                    new
            {
                action = "ContactOwners|ManagePackageOwners"
            }), permanent: true).To(packageActionRoute);

            // TODO: this route looks broken as there is no EditPackage action
            //routes.Redirect(
            //    r => r.MapRoute(
            //        "EditPackage",
            //        "Package/Edit/{id}/{version}",
            //        new { controller = PackagesController.ControllerName, action = "EditPackage" }),
            //    permanent: true).To(packageVersionActionRoute);

            routes.Redirect(r => r.MapRoute(RouteName.ListPackages, "List/Packages", MVC.Packages.ListPackages()), permanent: true).To(packageListRoute);

            routes.Redirect(r => r.MapRoute(RouteName.DisplayPackage, "List/Packages/{id}/{version}", MVC.Packages.DisplayPackage().AddRouteValue("version", UrlParameter.Optional)), permanent: true)
            .To(packageDisplayRoute);

            routes.Redirect(r => r.MapRoute(RouteName.NewSubmission, "Contribute/NewSubmission", MVC.Packages.UploadPackage()), permanent: true).To(uploadPackageRoute);
        }
Example #28
0
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{*favicon}", new { favicon = @"(.*/)?favicon.ico(/.*)?" });
            routes.IgnoreRoute("{*Content}", new { imgs = @"(.*/)?Content(/.*)?" });
            routes.IgnoreRoute("{*Scripts}", new { scripts = @"(.*/)?Scripts(/.*)?" });

            routes.MapRoute(RouteName.Home, "", MVC.Pages.Home());

            routes.MapRouteSeo(
                RouteName.InstallerBatchFile, "installChocolatey.cmd", new
            {
                controller = "Pages",
                Action     = "InstallerBatchFile"
            });

            routes.MapRouteSeo(
                RouteName.Features, "features", new
            {
                controller = "Pages",
                Action     = "Features"
            });

            routes.MapRouteSeo(
                RouteName.About, "about", new
            {
                controller = "Pages",
                Action     = "About"
            });

            routes.MapRouteSeo(
                RouteName.Notice, "notice", new
            {
                controller = "Pages",
                Action     = "Notice"
            });

            var pricingRoute = routes.MapRoute(
                RouteName.Pricing, "pricing", new
            {
                controller = "Pages",
                Action     = "Pricing"
            });

            routes.Redirect(r => r.MapRoute(RouteName.Compare, "compare")).To(pricingRoute);

            routes.MapRouteSeo(
                RouteName.Install, "install", new
            {
                controller = "Pages",
                Action     = "Install"
            });

            routes.MapRouteSeo(
                RouteName.Business, "business", new
            {
                controller = "Pages",
                Action     = "Business"
            });

            routes.MapRouteSeo(
                RouteName.FAQ, "faq", new
            {
                controller = "Pages",
                Action     = "FAQ"
            });

            routes.MapRouteSeo(
                RouteName.Kickstarter, "kickstarter", new
            {
                controller = "Pages",
                Action     = "Kickstarter"
            });

            routes.MapRouteSeo(
                RouteName.Terms, "terms", new
            {
                controller = "Pages",
                Action     = "Terms"
            });

            routes.MapRouteSeo(
                RouteName.Privacy, "privacy", new
            {
                controller = "Pages",
                Action     = "Privacy"
            });

            routes.MapRouteSeo(
                RouteName.Media, "media", new
            {
                controller = "Pages",
                Action     = "Media"
            });

            routes.MapRouteSeo(
                RouteName.Company, "company", new
            {
                controller = "Pages",
                Action     = "Company"
            });

            routes.MapRouteSeo(
                RouteName.ContactUs, "contact", new
            {
                controller = "Pages",
                Action     = "ContactUs"
            });

            routes.MapRouteSeo(
                RouteName.Support, "support", new
            {
                controller = "Pages",
                Action     = "Support"
            });

            routes.MapRouteSeo(
                RouteName.ReportIssue, "bugs", new
            {
                controller = "Pages",
                Action     = "ReportIssue"
            });

            routes.MapRouteSeo(
                RouteName.Press, "press", new
            {
                controller = "Pages",
                Action     = "Press"
            });

            routes.MapRouteSeo(
                RouteName.Partner, "partner", new
            {
                controller = "Pages",
                Action     = "Partner"
            });

            routes.MapRouteSeo(
                RouteName.Security, "security", new
            {
                controller = "Pages",
                Action     = "Security"
            });

            routes.MapRouteSeo(
                RouteName.Docs,
                "docs/{docName}",
                new { controller = "Documentation", action = "Documentation", docName = "home" }
                );

            routes.MapRoute(RouteName.Stats, "stats", MVC.Pages.Stats());

            routes.MapRoute(
                "rss feed", "feed.rss", new
            {
                controller = "RSS",
                Action     = "feed.rss"
            });

            routes.Add(new JsonRoute("json/{controller}"));

            routes.MapRoute(RouteName.Policies, "policies/{action}", MVC.Pages.Terms());

            var packageListRoute = routes.MapRoute(RouteName.ListPackages, "packages", MVC.Packages.ListPackages());

            routes.MapRoute(
                RouteName.NotifyComment, "packages/{packageId}/notify-comment", new
            {
                controller = MVC.Packages.Name,
                action     = "NotifyMaintainersOfAddedComment"
            });

            var uploadPackageRoute = routes.MapRoute(RouteName.UploadPackage, "packages/upload", MVC.Packages.UploadPackage());

            routes.MapRoute(RouteName.VerifyPackage, "packages/verify-upload", MVC.Packages.VerifyPackage());

            routes.MapRoute(RouteName.CancelUpload, "packages/cancel-upload", MVC.Packages.CancelUpload());

            routes.MapRoute(
                RouteName.PackageOwnerConfirmation, "packages/{id}/owners/{username}/confirm/{token}", new
            {
                controller = MVC.Packages.Name,
                action     = "ConfirmOwner"
            });

            // We need the following two routes (rather than just one) due to Routing's
            // Consecutive Optional Parameter bug. :(
            var packageDisplayRoute = routes.MapRoute(
                RouteName.DisplayPackage, "packages/{id}/{version}", MVC.Packages.DisplayPackage().AddRouteValue("version", UrlParameter.Optional), null /*defaults*/, new
            {
                version = new VersionRouteConstraint()
            });

            var packageVersionActionRoute = routes.MapRoute(
                RouteName.PackageVersionAction, "packages/{id}/{version}/{action}", new
            {
                controller = MVC.Packages.Name
            }, new
            {
                version = new VersionRouteConstraint()
            });

            var packageActionRoute = routes.MapRoute(
                RouteName.PackageAction, "packages/{id}/{action}", new
            {
                controller = MVC.Packages.Name
            });

            var resendRoute = routes.MapRoute("ResendConfirmation", "account/ResendConfirmation", MVC.Users.ResendConfirmation());

            //Redirecting v1 Confirmation Route
            routes.Redirect(r => r.MapRoute("v1Confirmation", "Users/Account/ChallengeEmail")).To(resendRoute);

            routes.MapRoute(
                RouteName.Authentication, "users/account/{action}", new
            {
                controller = MVC.Authentication.Name
            });

            routes.MapRoute(RouteName.Profile, "profiles/{username}", MVC.Users.Profiles());

            routes.MapRoute(RouteName.PasswordReset, "account/{action}/{username}/{token}", MVC.Users.ResetPassword());

            routes.MapRoute(RouteName.Account, "account/{action}", MVC.Users.Account());

            routes.MapRoute(
                "site" + RouteName.DownloadPackage, "packages/{id}/{version}/DownloadPackage", MVC.Api.GetPackage(), defaults: new
            {
                version = UrlParameter.Optional
            }, constraints: new
            {
                httpMethod = new HttpMethodConstraint("GET")
            });

            // V1 Routes
            routes.MapRoute("v1Legacy" + RouteName.PushPackageApi, "PackageFiles/{apiKey}/nupkg", MVC.Api.CreatePackagePost());
            routes.MapRoute("v1Legacy" + RouteName.PublishPackageApi, "PublishedPackages/Publish", MVC.Api.PublishPackage());

            // V2 routes
            routes.MapRoute(
                "v2" + RouteName.VerifyPackageKey, "api/v2/verifykey/{id}/{version}", MVC.Api.VerifyPackageKey(), defaults: new
            {
                id      = UrlParameter.Optional,
                version = UrlParameter.Optional
            });

            routes.MapRoute(
                "v2" + RouteName.DownloadPackage, "api/v2/package/{id}/{version}", MVC.Api.GetPackage(), defaults: new
            {
                version = UrlParameter.Optional
            }, constraints: new
            {
                httpMethod = new HttpMethodConstraint("GET")
            });

            routes.MapRoute(
                "v2" + RouteName.PushPackageApi, "api/v2/package", MVC.Api.CreatePackagePut(), defaults: null, constraints: new
            {
                httpMethod = new HttpMethodConstraint("PUT")
            });

            routes.MapRoute(
                "v2" + RouteName.DeletePackageApi, "api/v2/package/{id}/{version}", MVC.Api.DeletePackage(), defaults: null, constraints: new
            {
                httpMethod = new HttpMethodConstraint("DELETE")
            });

            routes.MapRoute(
                "v2" + RouteName.PublishPackageApi, "api/v2/package/{id}/{version}", MVC.Api.PublishPackage(), defaults: null, constraints: new
            {
                httpMethod = new HttpMethodConstraint("POST")
            });

            routes.MapServiceRoute(RouteName.V2ApiSubmittedFeed, "api/v2/submitted", typeof(V2SubmittedFeed));

            routes.MapRoute(
                "v2" + RouteName.TestPackageApi,
                "api/v2/test/{id}/{version}",
                MVC.Api.TestPackage(),
                defaults: null,
                constraints: new
            {
                httpMethod = new HttpMethodConstraint("POST")
            }
                );

            routes.MapRoute(
                "v2" + RouteName.ValidatePackageApi,
                "api/v2/validate/{id}/{version}",
                MVC.Api.ValidatePackage(),
                defaults: null,
                constraints: new
            {
                httpMethod = new HttpMethodConstraint("POST")
            }
                );

            routes.MapRoute(
                "v2" + RouteName.CleanupPackageApi,
                "api/v2/cleanup/{id}/{version}",
                MVC.Api.CleanupPackage(),
                defaults: null,
                constraints: new
            {
                httpMethod = new HttpMethodConstraint("POST")
            }
                );

            routes.MapRoute(
                "v2" + RouteName.DownloadCachePackageApi,
                "api/v2/cache/{id}/{version}",
                MVC.Api.DownloadCachePackage(),
                defaults: null,
                constraints: new
            {
                httpMethod = new HttpMethodConstraint("POST")
            }
                );

            routes.MapRoute(
                "v2" + RouteName.ScanPackageApi,
                "api/v2/scan/{id}/{version}",
                MVC.Api.ScanPackage(),
                defaults: null
                );

            routes.MapRoute("v2PackageIds", "api/v2/package-ids", MVC.Api.GetPackageIds());

            routes.MapRoute("v2PackageVersions", "api/v2/package-versions/{id}", MVC.Api.GetPackageVersions());

            routes.MapServiceRoute(RouteName.V2ApiFeed, "api/v2/", typeof(V2Feed));

            // Redirected Legacy Routes

            routes.Redirect(r => r.MapRoute("ReportAbuse", "Package/ReportAbuse/{id}/{version}", MVC.Packages.ReportAbuse()), permanent: true).To(packageVersionActionRoute);

            routes.Redirect(
                r => r.MapRoute(
                    "PackageActions", "Package/{action}/{id}", MVC.Packages.ContactOwners(), null /*defaults*/, // This next bit looks bad, but it's not. It will never change because
                    // it's mapping the legacy routes to the new better routes.
                    new
            {
                action = "ContactOwners|ManagePackageOwners"
            }), permanent: true).To(packageActionRoute);

            // TODO: this route looks broken as there is no EditPackage action
            //routes.Redirect(
            //    r => r.MapRoute(
            //        "EditPackage",
            //        "Package/Edit/{id}/{version}",
            //        new { controller = PackagesController.ControllerName, action = "EditPackage" }),
            //    permanent: true).To(packageVersionActionRoute);

            routes.Redirect(r => r.MapRoute(RouteName.ListPackages, "List/Packages", MVC.Packages.ListPackages()), permanent: true).To(packageListRoute);

            routes.Redirect(r => r.MapRoute(RouteName.DisplayPackage, "List/Packages/{id}/{version}", MVC.Packages.DisplayPackage().AddRouteValue("version", UrlParameter.Optional)), permanent: true)
            .To(packageDisplayRoute);

            routes.Redirect(r => r.MapRoute(RouteName.NewSubmission, "Contribute/NewSubmission", MVC.Packages.UploadPackage()), permanent: true).To(uploadPackageRoute);
        }
        /// <summary>
        /// Registers the routes.
        /// </summary>
        /// <param name="routes">The routes.</param>
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("virto/services/{MyJob}.svc/{*pathInfo}");
            routes.IgnoreRoute("virto/dataservices/{MyJob}.svc/{*pathInfo}");
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
            routes.IgnoreRoute(".html");

            //Ignore all calls to bundles
            routes.IgnoreRoute("bundles/{*pathInfo}");
            //Ignore all calls to areas (Areas supposed to serve own routes)
            routes.IgnoreRoute("areas/{*pathInfo}");

            //This makes sure index.html (or any other deafult document is opened for empty url
            routes.IgnoreRoute("");

            routes.MapRoute(
                "FailWhale",
                "FailWhale/{action}/{id}", new { controller = "Error", action = "FailWhale", id = UrlParameter.Optional });

            routes.MapRoute(
              "Assets",
              "asset/{*path}",
              new { controller = "Asset", action = "Index", path = UrlParameter.Optional });

            var itemRoute = new NormalizeRoute(
                new ItemRoute(Constants.ItemRoute,
                    new RouteValueDictionary
                    {
                        {"controller", "Catalog"},
                        {"action", "DisplayItem"},
                        {Constants.Language, UrlParameter.Optional}
                    },
                    new RouteValueDictionary
                    {
                        {Constants.Language, new LanguageRouteConstraint()},
                        {Constants.Store, new StoreRouteConstraint()},
                        {Constants.Category, new CategoryRouteConstraint()},
                        {Constants.Item, new ItemRouteConstraint()}
                    },
                    new RouteValueDictionary { { "namespaces", new[] { "VirtoCommerce.Web.Controllers" } } },
                new MvcRouteHandler()));

            var categoryRoute = new NormalizeRoute(
                new CategoryRoute(Constants.CategoryRoute,
                    new RouteValueDictionary
                    {
                        {"controller", "Catalog"},
                        {"action", "Display"},
                        {Constants.Language, UrlParameter.Optional}
                    },
                 new RouteValueDictionary
                    {
                        {Constants.Language, new LanguageRouteConstraint()},
                        {Constants.Store, new StoreRouteConstraint()},
                        {Constants.Category, new CategoryRouteConstraint()}
                    },
                new RouteValueDictionary { { "namespaces", new[] { "VirtoCommerce.Web.Controllers" } } },
                new MvcRouteHandler()));

            var storeRoute = new NormalizeRoute(
                new StoreRoute(Constants.StoreRoute,
                 new RouteValueDictionary
                    {
                        {"controller", "Home"},
                        {"action", "Index"}
                    },
                new RouteValueDictionary
                    {
                        {Constants.Language, new LanguageRouteConstraint()},
                        {Constants.Store, new StoreRouteConstraint()}
                    },
                new RouteValueDictionary { { "namespaces", new[] { "VirtoCommerce.Web.Controllers" } } },
                new MvcRouteHandler()));

            routes.Add("Item", itemRoute);
            routes.Add("Category", categoryRoute);
            routes.Add("Store", storeRoute);

            //Legacy redirects
            routes.Redirect(r => r.MapRoute("old_Category", string.Format("c/{{{0}}}", Constants.Category))).To(categoryRoute,
                x =>
                {
                    //Expect to receive category code
                    if (x.RouteData.Values.ContainsKey(Constants.Category))
                    {
                        var category = CatalogHelper.CatalogClient.GetCategory(x.RouteData.Values[Constants.Category].ToString());
                        if (category != null)
                        {
                            return new RouteValueDictionary { { Constants.Category, category.CategoryId } };
                        }
                    }
                    return null;
                });
            routes.Redirect(r => r.MapRoute("old_Item", string.Format("p/{{{0}}}", Constants.Item))).To(itemRoute,
                x =>
                {
                    //Resolve item category dynamically
                    //Expect to receive item code
                    if (x.RouteData.Values.ContainsKey(Constants.Item))
                    {
                        var item = CatalogHelper.CatalogClient.GetItemByCode(x.RouteData.Values[Constants.Item].ToString(), StoreHelper.CustomerSession.CatalogId);
                        if (item != null)
                        {
                            return new RouteValueDictionary { { Constants.Category, item.GetItemCategoryRouteValue() } };
                        }
                    }
                    return null;
                });

            var defaultRoute = new NormalizeRoute(new Route(string.Format("{{{0}}}/{{controller}}/{{action}}/{{id}}", Constants.Language),
                new RouteValueDictionary { { "id", UrlParameter.Optional }, { "action", "Index" } },
                new RouteValueDictionary { { Constants.Language, new LanguageRouteConstraint() } },
                new RouteValueDictionary { { "namespaces", new[] { "VirtoCommerce.Web.Controllers" } } },
                new MvcRouteHandler()));

            //Other actions
            routes.Add("Default", defaultRoute);

            //Needed for some post requests
            routes.MapRoute(
                "Default_Fallback", // Route name
                "{controller}/{action}/{id}", // URL with parameters
                new
                {
                    action = "Index",
                    id = UrlParameter.Optional
                }, // Parameter defaults
                new[] { "VirtoCommerce.Web.Controllers" });
        }