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 registerResponseHelperHandlers(routes *wcg.Router) {
routes.Before(func(res *wcg.Response, req *wcg.Request) {
var app *App
tmp := strings.Split(req.URL().Path, "/")
req.Logger.Info("App is :%s", tmp[1])
switch tmp[1] {
case "api", "cron":
app = apps[tmp[2]]
break
default:
app = apps[tmp[1]]
}
if app == nil {
req.Logger.Debug("No app is identified.")
return
}
// request locals
req.SetLocal(LOCAL_APP_KEY, app)
res.SetLocal(LOCAL_APP_KEY, app)
// response locals
uk := GetUserKind(req)
navs := make([]*Page, 0)
for _, nav := range app.navigations {
req.Logger.Debug("Checking %s nav availablity: (%d, %d)", nav.Title, uk, nav.authority)
if uk >= nav.authority {
navs = append(navs, nav)
}
}
res.SetLocal(LOCAL_NAVIGATIONS_KEY, navs)
})
}
func (t *TestRequest) RouteTo(r *wcg.Router) *TestResponse {
r.Dispatch(t.res, t.Request)
body, err := ioutil.ReadAll(t.recorder.Body)
if err != nil {
panic(err)
}
return &TestResponse{
t.recorder.Code,
t.recorder.Header(),
body,
t,
}
}
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 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)
}
})
}
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 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)
}