func authOnly(next myHandler) myHandler { return func(ctx *Context, w http.ResponseWriter, r *http.Request) error { if ctx.user == nil { url, err := user.LoginURL(ctx.c, "/login") if err != nil { return err } ctx.SetTitle("Please log in to continue ...") return ctx.Render(signinTmpl, url) } err := ctx.LoadUserSession() if err != nil { return err } if ctx.userSession == nil { url, err := user.LoginURL(ctx.c, "/login") if err != nil { return err } ctx.SetTitle("Invalid user ...") return ctx.Render(signinTmpl, url) } return next(ctx, w, r) } }
func adminHandler(w http.ResponseWriter, r *http.Request) { if r.URL.Path != "/admin/" { errorHandler(w, r, http.StatusNotFound) return } admin := template.Must(template.ParseFiles( "http/html/_base.html", "http/html/admin.html", )) c := appengine.NewContext(r) u := user.Current(c) if u == nil { url, err := user.LoginURL(c, r.URL.String()) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Set("Location", url) w.WriteHeader(http.StatusFound) return } if !u.Admin { url, _ := user.LoginURL(c, r.URL.String()) w.Header().Set("Location", url) w.WriteHeader(http.StatusFound) return } admin.Execute(w, nil) }
func admin(w http.ResponseWriter, r *http.Request) { // handle requests to "/admin/" c := appengine.NewContext(r) billQuery := datastore.NewQuery("Bill").Order("-Session").Order("-Number") bills := make([]bill.Bill, 0) if _, err := billQuery.GetAll(c, &bills); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } senatorQuery := datastore.NewQuery("Senator").Order("-Name") senators := make([]senator.Senator, 0) if _, err := senatorQuery.GetAll(c, &senators); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } login, _ := user.LoginURL(c, "/") logout, _ := user.LogoutURL(c, "/") pageInfo := PageInfo{Title: "Administrator Dashboard", User: user.Current(c), Admin: user.IsAdmin(c), LoginURL: login, LogoutURL: logout, Bills: bills, Senators: senators} if err := adminTemplate.Execute(w, pageInfo); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) } }
func webuserOK(c appengine.Context, w http.ResponseWriter, r *http.Request) bool { if !userauthenticated(c) { url, err := user.LoginURL(c, r.URL.String()) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return false } w.Header().Set("Location", url) w.WriteHeader(http.StatusFound) return false } u := user.Current(c) authzed, err := userauthorized(c, u.Email) if err != nil { c.Errorf("authorization error: %v", err) http.Error(w, err.Error(), http.StatusInternalServerError) return false } if !authzed { c.Warningf("authorization failure: %v", u.Email) w.WriteHeader(http.StatusForbidden) err = templates.ExecuteTemplate(w, "unauthorized.html", nil) if err != nil { c.Errorf("unauthorized user and got err on template: %v", err) } return false } return true }
func createPageHeader(title string, w http.ResponseWriter, r *http.Request) *PageHeader { pageHeader := &PageHeader{Title: title} c := appengine.NewContext(r) u := user.Current(c) if u == nil { url, err := user.LoginURL(c, r.URL.String()) if err != nil { panic("user.LoginURL error: " + err.Error()) } pageHeader.UserURL = url pageHeader.UserLabel = "Login" pageHeader.IsAdmin = false } else { url, err := user.LogoutURL(c, r.URL.String()) if err != nil { panic("user.LogoutURL error: " + err.Error()) } pageHeader.UserURL = url pageHeader.UserLabel = "Logout" pageHeader.LoginMessage = "Hello, " + u.String() + "!" pageHeader.IsAdmin = user.IsAdmin(c) w.Header().Set("Pragma", "no-cache") } return pageHeader }
// require_login is a wrapper for a function that serves web pages. // By wrapping the function in require_login, the user is forced to // log in to their Google account in order to access the system. func require_login(H handler) handler { return func(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) // Force the person to log in. client := user.Current(c) if client == nil { U := strings.Split(r.URL.String(), "/") V := U[len(U)-1] url, err := user.LoginURL(c, V) if err != nil { http.Error(w, "Error", http.StatusInternalServerError) return } c.Infof(fmt.Sprintf("Login url: %s", url)) msg := "To use this site, you must be logged into your Google account." return_msg := "Continue to login page" Message_page(w, r, nil, msg, return_msg, url) return } H(w, r) } }
func AppstatsHandler(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) if appengine.IsDevAppServer() { // noop } else if u := user.Current(c); u == nil { if loginURL, err := user.LoginURL(c, r.URL.String()); err == nil { http.Redirect(w, r, loginURL, http.StatusTemporaryRedirect) } else { serveError(w, err) } return } else if !u.Admin { http.Error(w, "Forbidden", http.StatusForbidden) return } if detailsURL == r.URL.Path { Details(w, r) } else if fileURL == r.URL.Path { File(w, r) } else if strings.HasPrefix(r.URL.Path, staticURL) { Static(w, r) } else { Index(w, r) } }
func handler(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) u := user.Current(c) if u == nil { loginUrl, _ := user.LoginURL(c, "/todo") http.Redirect(w, r, loginUrl, http.StatusFound) return } // start 2 OMIT t, err := template.ParseFiles("todo/todo.tmpl") // テンプレート読み込み // HL if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Set("Content-type", "text/html; charset=utf-8") logoutUrl, _ := user.LogoutURL(c, "/") params := struct { LogoutUrl string User *user.User }{ logoutUrl, u, } err = t.Execute(w, params) // テンプレート適用! // HL if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } // end 2 OMIT }
// NewParams returns a new initialized Params func NewParams(r *http.Request, page *Page) *Params { now := time.Now() c := appengine.NewContext(r) p := Params{Pages: Pages, PathPageMap: PathPageMap, NamePageMap: NamePageMap, Request: r, Mobile: isMobile(r), Page: page, Start: now, AppCtx: c, Custom: make(map[string]interface{})} p.User = user.Current(c) if p.User == nil { p.LoginURL, p.Err = user.LoginURL(c, r.URL.String()) } else { p.LogoutURL, p.Err = user.LogoutURL(c, r.URL.String()) if p.Err != nil { // Log if error, but this is not a show-stopper: c.Errorf("Error getting logout URL: %s", p.Err.Error()) } p.Account, p.Err = cache.GetAccount(p.Request, c, p.User) } if p.Err != nil { c.Errorf("ERROR: %s", p.Err.Error()) } return &p }
func GetGameInfo(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) u := user.Current(c) if u == nil { c.Infof("Not logged in") url, _ := user.LoginURL(c, "/") fmt.Fprintf(w, `<a href="%s">Sign in or register</a>`, url) return } if !users.IsUserSignedIn(c) { fmt.Fprintf(w, "Not Registerd") return } id, pErr := strconv.ParseInt(r.FormValue("game_id"), 10, 32) if pErr != nil { c.Infof("Error parseing int: %v", pErr) http.Error(w, pErr.Error(), http.StatusInternalServerError) return } mGame, _, err := GetGame(c, int(id)) if err != nil { c.Infof("Error getting game: %v", err) http.Error(w, err.Error(), http.StatusInternalServerError) return } mess, jErr := json.Marshal(mGame) if jErr != nil { c.Infof("Error json marshal: %v", jErr) http.Error(w, jErr.Error(), http.StatusInternalServerError) return } fmt.Fprintf(w, string(mess)) }
func ensureProfile(w http.ResponseWriter, r *http.Request) (*datastore.Key, *Profile) { c := appengine.NewContext(r) u := user.Current(c) if u == nil { url, err := user.LoginURL(c, r.URL.String()) check(err) w.Header().Set("Location", url) w.WriteHeader(http.StatusFound) return nil, nil } q := datastore.NewQuery("Profile").Filter("Username="******"Profile", nil), &p) check(err) w.Header().Set("Location", r.URL.String()) w.WriteHeader(http.StatusFound) return nil, nil }
func registration(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) u := User{ Name: "TestHendrik", StartDate: datastore.SecondsToTime(time.Seconds()), } if g := user.Current(c); g != nil { var u2 User u.Account = g.String() if err := datastore.Get(c, datastore.NewKey("user", g.String(), 0, nil), &u2); err == datastore.ErrNoSuchEntity { key, err := datastore.Put(c, datastore.NewKey("user", u.Account, 0, nil), &u) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } fmt.Fprintf(w, "User %q stored %q", u.Account, key) return } else { fmt.Fprintf(w, "User %q is already logged in", g.String()) return } } else { url, err := user.LoginURL(c, r.URL.String()) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } w.Header().Set("Location", url) w.WriteHeader(http.StatusFound) return } }
func Root(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) var u *user.User if u = user.Current(c); u == nil { url, err := user.LoginURL(c, r.URL.String()) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Set("Location", url) w.WriteHeader(http.StatusFound) return } // Get last numEntries entries & display them q := datastore.NewQuery("Entry").Ancestor(userKey(u.Email, c)).Order("-Time").Limit(numEntries) entries := make([]entry.Entry, 0, numEntries) if _, err := q.GetAll(c, &entries); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } for i := 0; i < len(entries)/2; i++ { entries[i], entries[len(entries)-i-1] = entries[len(entries)-i-1], entries[i] } for i, _ := range entries { entries[i].Time = entries[i].Time.Round(10 * time.Millisecond) } if err := homeTemplate.Execute(w, map[string]interface{}{ "User": u.Email, "Entries": entries}); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } }
func AdminHandler(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) db := DB{c} adminUser := user.Current(c) if adminUser == nil { url, _ := user.LoginURL(c, "/admin/dashboard") http.Redirect(w, r, url, 301) return } if r.Method == "GET" { dir := path.Join(os.Getenv("PWD"), "templates") admin := path.Join(dir, "admin.html") data := map[string]interface{}{"user": adminUser.String(), "config": Config} page := mustache.RenderFile(admin, data) fmt.Fprint(w, page) } else if r.Method == "POST" { if len(r.FormValue("v")) == 0 { return } switch r.FormValue("op") { case "UnqueueUser": db.Context.Infof("unqueuing %v", r.FormValue("v")) db.UnqueueUser(r.FormValue("v")) case "BatchUsers": users := strings.Split(r.FormValue("v"), ",") for _, v := range users { QueueUser(v, c) } } fmt.Fprintf(w, "{\"op\":\"%v\",\"success\":true}", r.FormValue("op")) } }
func root(w http.ResponseWriter, r *http.Request) { if r.Method != "GET" || r.URL.Path != "/" { serve404(w) return } c := appengine.NewContext(r) u := user.Current(c) gg, err := brg.GetBuriggies(c, 100) if err != nil { serveError(c, w, err) return } log.Println("hoi") loginUrl, _ := user.LoginURL(c, "/") logoutUrl, _ := user.LogoutURL(c, "/") mdi := modelIndex{Buriggies: gg, User: u, LoginUrl: loginUrl, LogoutUrl: logoutUrl} t, errTpl := template.ParseFiles("code/main.tpl") if errTpl != nil { serveError(c, w, errTpl) return } if err := t.Execute(w, mdi); err != nil { c.Errorf("%v", err) } }
/** * get logout link with redirection url * @param {[type]} w http.ResponseWriter [description] * @param {[type]} r *http.Request [description] * @return {[type]} [description] */ func getAdminUserLogout(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) body, err := ioutil.ReadAll(io.LimitReader(r.Body, 1048576)) if err != nil { panic(err) } if err := r.Body.Close(); err != nil { panic(err) } redirect := Redirect{} if err := json.Unmarshal(body, &redirect); err != nil { SetError(w, r, 400, "") return } u := user.Current(c) connected := (u != nil) if !connected { uriResponse := &Uri{ Uri: "", } json.NewEncoder(w).Encode(uriResponse) } else { uri, _ := user.LoginURL(c, redirect.Redirect) uriResponse := &Uri{ Uri: uri, } json.NewEncoder(w).Encode(uriResponse) } return }
/** * get admin user info and connect/disconnect link * @param {[type]} w http.ResponseWriter [description] * @param {[type]} r *http.Request [description] * @return {[type]} [description] */ func getCurrentUser(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) u := user.Current(c) connected := (u != nil) if !connected { uri, _ := user.LoginURL(c, "/") currentUser := &CurrentUser{ Connected: connected, Admin: false, Config: true, Uri: uri, } json.NewEncoder(w).Encode(currentUser) } else { uri, _ := user.LogoutURL(c, "/") currentUser := &CurrentUser{ Connected: connected, Admin: u.Admin, Config: true, Uri: uri, } json.NewEncoder(w).Encode(currentUser) } return }
func fg(w http.ResponseWriter, r *http.Request) { // Start by checking so that the user is logged in! c := appengine.NewContext(r) c.Infof("THis is info") u := user.Current(c) if u == nil { c.Infof("User not signed in") // Generate a response that may be used to login the user // since this might be needed! str, er := user.LoginURL(c, "https://vronpass.appspot.com/") if er != nil { w.WriteHeader(http.StatusBadRequest) return } w.WriteHeader(http.StatusUnauthorized) w.Write([]byte(str)) return } // We simply store the information under the username! path := u.Email k := datastore.NewKey(c, "Entity", path, 0, nil) e := new(Entity) if err := datastore.Get(c, k, e); err != nil { // This does not exist so simply return a empty response w.Write([]byte("{}")) return } // Otherwise return the string w.Write([]byte(e.Value)) }
func admin(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) u := user.Current(c) if u == nil { url, err := user.LoginURL(c, r.URL.String()) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Set("Location", url) w.WriteHeader(http.StatusFound) return } /* Si el usuario es administrador. */ if user.IsAdmin(c) { categorias := getCategorias(c, 10) contenido := ContenidoAdmin{categorias} /* Ejecuto el template y envio la salida al Writer. */ err2 := adminTpl.Execute(w, contenido) if err2 != nil { http.Error(w, err2.Error(), http.StatusInternalServerError) } } else { fmt.Fprint(w, "El usuario no es admin.") } }
func handler(w http.ResponseWriter, r *http.Request) { // [START new_context] c := appengine.NewContext(r) // [END new_context] // [START get_current_user] u := user.Current(c) // [END get_current_user] // [START if_user] if u == nil { url, err := user.LoginURL(c, r.URL.String()) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Set("Location", url) w.WriteHeader(http.StatusFound) return } w.Header().Set("myLocation", r.URL.String()) w.Header().Set("myname", "todd") w.WriteHeader(http.StatusOK) // [END if_user] // [START output] fmt.Fprintf(w, "Hello, %v!", u) // [END output] }
func root(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) pageData := TodoPageData{} if u := user.Current(c); u == nil { pageData.Username = "******" url, err := user.LoginURL(c, r.URL.String()) handleErr(w, err) pageData.LoginUrl = url } else { pageData.Username = u.String() url, err := user.LogoutURL(c, r.URL.String()) handleErr(w, err) pageData.LoginUrl = url } q := datastore.NewQuery(pageData.Username).Order("-Created").Limit(10) //make is like a constructor //[] is a "slice", ref counted, dynamic array items := make([]TodoItem, 0, 10) _, err := q.GetAll(c, &items) pageData.TodoItems = items templ, err := template.ParseFiles("todo.html") handleErr(w, err) err = templ.Execute(w, pageData) // populate html page with data from pageData handleErr(w, err) }
func Admin(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) u := user.Current(c) an := AdminPage{"", ""} var templ = "" if u == nil { url, err := user.LoginURL(c, r.URL.String()) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Set("Location", url) w.WriteHeader(http.StatusFound) return } c.Debugf("User present %v", u) an.Admin_email = u.Email templ = "adminIndex" url, err := user.LogoutURL(c, "/admin") if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } an.LogoutUrl = url err = templates.ExecuteTemplate(w, templ, an) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } }
func join(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) u := user.Current(c) if u == nil { url, err := user.LoginURL(c, r.URL.String()) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } w.Header().Set("Location", url) w.WriteHeader(http.StatusFound) return } r.ParseForm() // TODO check table arg state, err := joinTable(c, r.Form["table"][0], u.String()) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } var b []byte b, err = json.Marshal(state) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } fmt.Fprintf(w, "%s", b) }
func LoginPageHtml(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) client := urlfetch.Client(c) loginPageURL, _ := user.LoginURL(c, "/admin/") if !strings.HasPrefix(loginPageURL, "http") { loginPageURL = "https://goblog-geoct826.c9.io/" + loginPageURL } loginPageURL = loginPageURL + "&output=embed" resp, err := client.Get(loginPageURL) if err != nil { //log.Println(err) fmt.Fprintf(w, "Sorry, something went wrong") return } defer resp.Body.Close() contents, err1 := ioutil.ReadAll(resp.Body) if err1 != nil { //log.Println(err) fmt.Fprintf(w, "Sorry, something went wrong") return } fmt.Fprintf(w, string(contents)) }
func ninjalogForm(w http.ResponseWriter, req *http.Request) { if req.Method == "POST" { ninjalogUpload(w, req) return } ctx := appengine.NewContext(req) u := user.Current(ctx) login, err := user.LoginURL(ctx, "/ninja_log/") if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } logout, err := user.LogoutURL(ctx, "/ninja_log/") if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Set("Content-Type", "text/html") w.WriteHeader(http.StatusOK) data := struct { User *user.User Login string Logout string }{ User: u, Login: login, Logout: logout, } err = formTmpl.Execute(w, data) if err != nil { ctx.Errorf("formTmpl: %v", err) } }
func SearchHandler(w http.ResponseWriter, r *http.Request) { data := make(map[string]string) c := appengine.NewContext(r) u := user.Current(c) if u != nil { data["Email"] = u.String() upload_url, upload_err := blobstore.UploadURL(c, "/upload") if upload_err != nil { c.Logf("blob store is disabled? %v", upload_err) data["Upload_Action"] = "/upload" } else { data["Upload_Action"] = upload_url.String() } } else { url, err := user.LoginURL(c, r.URL.String()) if err != nil { http.Error(w, err.String(), http.StatusInternalServerError) return } data["Login_url"] = url } data["Base_person"] = "{\"name\": \"James Morrison\", \"Date of Birth\": [1981, 10, 2]}" template_err := searchTemplate.Execute(w, data) if template_err != nil { log.Print("Error rendering template ", template_err) } }
func newgame(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) u := user.Current(c) if u == nil { url, err := user.LoginURL(c, r.URL.String()) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Set("Location", url) w.WriteHeader(http.StatusFound) return } url, err := user.LogoutURL(c, r.URL.String()) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } i := Index{ User: u.Email, Login: false, URL: url, } if err := newGameTemplate.Execute(w, i); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) } }
func handlePost(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "text/html; charset=utf-8") if r.Method != "GET" || r.URL.Path != "/post" { serve404(w) return } c := appengine.NewContext(r) u := user.Current(c) if u == nil { url, err := user.LoginURL(c, r.URL.String()) if err != nil { serveError(c, w, err) return } w.Header().Set("Location", url) w.WriteHeader(http.StatusFound) return } if !user.IsAdmin(c) { serve404(w) return } uploadURL, err := blobstore.UploadURL(c, "/upload", nil) if err != nil { serveError(c, w, err) return } err = postTemplate.Execute(w, uploadURL) if err != nil { serveError(c, w, err) } }
// NewPage returns a new Page initialized embedding the template with the // given name and data, the current user for the given context, and the // latest announcement. func NewPage(ctx appengine.Context, name string, data interface{}) (*Page, error) { p := &Page{ Content: name, Data: data, Topics: topicList, Cities: cityList, } a, err := conf.LatestAnnouncement(ctx) if err != nil { ctx.Errorf("latest announcement: %v", err) } if a != nil { p.Announcement = a.Message } if u := user.Current(ctx); u != nil { p.User = u p.LogoutURL, err = user.LogoutURL(ctx, "/") } else { p.LoginURL, err = user.LoginURL(ctx, "/") } return p, err }
func root(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) u := user.Current(c) if u == nil { url, err := user.LoginURL(c, r.URL.String()) if err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } w.Header().Set("Location", url) w.WriteHeader(http.StatusFound) return } q := datastore.NewQuery("Greeting").Ancestor(guestbookKey(c)).Order("-Date").Limit(10) greetings := make([]Greeting, 0, 10) if _, err := q.GetAll(c, &greetings); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) return } if err := guestbookTemplate.Execute(w, greetings); err != nil { http.Error(w, err.Error(), http.StatusInternalServerError) } }