Golang Router.Get方法代码示例

func configurePosts(routes *wcg.Router) {
	routes.Get("/:blog_id/:post_id/", showPostHandler)
	routes.Post("/admin/blogs/:blog_id/", createPostHandler)
	routes.Get("/admin/blogs/:blog_id/:post_id/", editPostHandler)
	routes.Put("/admin/blogs/:blog_id/:post_id/", updatePostHandler)
	routes.Delete("/admin/blogs/:blog_id/:post_id/", deletePostHandler)
}

func configureOAuth(routes *wcg.Router) {
	GoogleAuthConfig, _ := google.NewAuthConfigFromFile("")
	FacebookAuthConfig, _ := facebook.NewAuthConfigFromFile("")
	GoogleAuthConfig.RedirectURL = "/login/google/callback"
	GoogleAuthConfig.TransportFactory = gae.NewHttpTransport
	GoogleAuthConfig.UnauthorizedHandler = unauthorized
	GoogleAuthConfig.AuthorizedHandler = authorized
	GoogleAuthConfig.InvalidatedHandler = invalidated
	gauth, gcallback, gvalidates, glogout := middleware.OAuth2(GoogleAuthConfig)
	routes.All("/*", gvalidates)
	routes.Get("/login/google", gauth)
	routes.Get("/login/google/callback", gcallback)
	routes.Get("/logout/google", glogout)

	FacebookAuthConfig.RedirectURL = "/login/facebook/callback"
	FacebookAuthConfig.TransportFactory = gae.NewHttpTransport
	FacebookAuthConfig.UnauthorizedHandler = unauthorized
	FacebookAuthConfig.AuthorizedHandler = authorized
	FacebookAuthConfig.InvalidatedHandler = invalidated
	fbauth, fbcallback, fbvalidates, fblogout := middleware.OAuth2(FacebookAuthConfig)
	routes.All("/*", fbvalidates)
	routes.All("/*", func(res *wcg.Response, req *wcg.Request) {
		res.SetLocal("fb_app_id", FacebookAuthConfig.ClientId)
	})
	routes.Get("/login/facebook", fbauth)
	routes.Get("/login/facebook/callback", fbcallback)
	routes.Post("/logout/facebook", fblogout)
}

func registerJsonpProxyHandlers(routes *wcg.Router) {
	routes.Get("/jsonp", func(res *wcg.Response, req *wcg.Request) {
		target := req.Query("_jsonpurl")
		if target == "" {
			res.WriteJsonWithStatus(400, nil, map[string]interface{}{
				"error": "_jsonpurl must be specified.",
			})
			return
		}
		if _url, err := url.Parse(target); err != nil {
			res.WriteJsonWithStatus(400, nil, map[string]interface{}{
				"error": "_jsonpurl cannot be parsed.",
			})
			return
		} else {
			if _url.Scheme != "http" && _url.Scheme != "https" {
				res.WriteJsonWithStatus(400, nil, map[string]interface{}{
					"error": "non http(s) scheme is allowed.",
				})
				return
			}
			if _, ok := JsonpProxyWhiteList[_url.Host]; !ok {
				res.WriteJsonWithStatus(400, nil, map[string]interface{}{
					"error": fmt.Sprintf("%s is not allowed to proxy.", _url.Host),
				})
				return
			}
		}
		query := req.HttpRequest().URL.Query()
		query.Del("_jsonpurl")
		client := gae.NewHttpClient(req)
		resp, err := client.Get(fmt.Sprintf("%s?%s", target, query.Encode()))
		if resp == nil {
			Error(res, req, err)
			return
		}
		defer resp.Body.Close()
		res.WriteHeader(resp.StatusCode)
		io.Copy(res, resp.Body)
	})
}

func registerCronHandlers(routes *wcg.Router) {
	routes.Get("/cron.yaml", func(res *wcg.Response, req *wcg.Request) {
		res.Header().Add("Content-Type", "text/yaml")
		res.WriteString("cron:\n")
		applist := make([]string, 0)
		for _, app := range apps {
			if len(app.Cron.entries) > 0 {
				applist = append(applist, app.Key)
			}
		}
		applist = sort.StringSlice(applist)
		for _, appName := range applist {
			app := apps[appName]
			res.WriteString("# Application -- %s\n", app.Key)
			for _, ent := range app.Cron.entries {
				res.WriteString("- url:         %s\n", ent.Url)
				res.WriteString("  schedule:    %s\n", ent.Schedule)
				res.WriteString("  description: %s\n", ent.Description)
				res.WriteString("  timezone:    %s\n\n", "Asia/Tokyo")
			}
		}
	})
}

func registerAhHandlers(routes *wcg.Router) {
	routes.Get("/_ah/start", func(res *wcg.Response, req *wcg.Request) {
		for _, app := range apps {
			if app.Start != nil {
				req.Logger.Info("%q start handler", app.Key)
				req.SetLocal(LOCAL_APP_KEY, app)
				res.SetLocal(LOCAL_APP_KEY, app)
				app.Start(res, req)
			}
		}
		res.WriteString("OK")
	})
	routes.Get("/_ah/warmup", func(res *wcg.Response, req *wcg.Request) {
		for _, app := range apps {
			if app.Warmup != nil {
				req.Logger.Info("%q warmup handler", app.Key)
				req.SetLocal(LOCAL_APP_KEY, app)
				res.SetLocal(LOCAL_APP_KEY, app)
				app.Warmup(res, req)
			}
		}
		res.WriteString("OK")
	})
}

func configureBlogs(routes *wcg.Router) {
	// check user is already signed in or not.
	routes.All("/admin/blogs/*", func(res *wcg.Response, req *wcg.Request) {
		if wcg.IsGuest(req.User) {
			res.Redirect("/", http.StatusFound)
		}
	})
	// public interfaces.
	routes.Get("/my/", myblogRedirector(true))
	routes.Get("/:blog_id/", showBlogHandler)
	// admin interfaces
	routes.Get("/admin/blogs/my/", myblogRedirector(false))
	routes.Get("/admin/blogs/:blog_id/", manageBlogHandler)
	routes.Post("/admin/blogs/", createBlogHandler)
	routes.Put("/admin/blogs/:blog_id/", updateBlogHandler)
	routes.Delete("/admin/blogs/:blog_id/", deleteBlogHandler)
}

func registerAuthHandlers(routes *wcg.Router) {
	middleware.SessionConfigIni.StoreFactory = gae.GAESessionStoreFactory
	sessionBefore, sessionAfter := middleware.SessionSupport()
	fbconfig := facebookConfig()
	fbauth, fbcallback, fbvalidates, fblogout := middleware.OAuth2(fbconfig)
	csrf := middleware.CSRFSupport()

	// resolve the access user
	routes.Before(func(res *wcg.Response, req *wcg.Request) {
		if apiTokenAuthHandler(res, req) {
			req.Logger.Debug("Api Token Auth: Yes")
			req.SetLocal(LOCAL_KEY_AUTH_TYPE, AUTH_TYPE_API_TOKEN)
			return
		}
		req.Logger.Debug("Api Token Auth: No")
		if cronAuthHandler(res, req) {
			req.Logger.Debug("Cron Auth: Yes")
			req.SetLocal(LOCAL_KEY_AUTH_TYPE, AUTH_TYPE_CRON)
			return
		}
		req.Logger.Debug("Cron Auth: No")

		if ahAuthHandler(res, req) {
			req.Logger.Debug("Ah Auth: Yes")
			req.SetLocal(LOCAL_KEY_AUTH_TYPE, AUTH_TYPE_AH)
			return
		}
		req.Logger.Debug("Ah Auth: No")
		req.Logger.Debug("Session Auth: Yes")

		sessionBefore(res, req)
		res.SetLocal(LOCAL_KEY_AUTH_TYPE, AUTH_TYPE_COOKIE)
		fbvalidates(res, req)

		res.SetLocal("fb_app_id", fbconfig.ClientId)
		res.SetLocal("wcg_user", util.FormatJson(map[string]interface{}{
			"id":           req.User.Id(),
			"display_name": req.User.DisplayName(),
			"image_link":   req.User.ImageLink(),
			"profile_link": req.User.ProfileLink(),
			"last_login":   req.User.LastLogin(),
			"user_kind":    GetUserKind(req),
		}))

		if req.Method() != "GET" && req.Method() != "HEAD" {
			csrf(res, req)
		}
	})

	// AUthorization Endpoint
	routes.Get("/login/facebook", func(res *wcg.Response, req *wcg.Request) {
		if req.Query("ref") != "" {
			req.Session.Set(SESSION_KEY_LOGIN_REF, req.Query("ref"))
		}
		fbauth(res, req)
	})
	routes.Get("/login/facebook/callback", fbcallback)
	routes.Post("/logout/facebook", func(res *wcg.Response, req *wcg.Request) {
		fblogout(res, req)
		res.Redirect("/", http.StatusFound)
	})

	// Save the session data
	routes.After(func(res *wcg.Response, req *wcg.Request) {
		if auth_type, ok := res.Local(LOCAL_KEY_AUTH_TYPE).(string); ok && auth_type == AUTH_TYPE_COOKIE {
			sessionAfter(res, req)
		}
	})
}