예제 #1
0
파일: main.go 프로젝트: AaronO/lightwave
func loginHandler(w http.ResponseWriter, r *http.Request) {
	// Determine the virtual host
	server, err := findServer(r.Host)
	if err != nil {
		errorHandler(w, r, err.String())
		return
	}

	username := r.FormValue("username")
	password := r.FormValue("password")
	log.Println("LOGIN:", username)
	if err = server.UserAccountDatabase.CheckCredentials(username, password); err != nil {
		log.Println(err)
		http.Redirect(w, r, server.Config.LoginPage, 303)
		return
	}
	s, err := server.SessionDatabase.CreateSession(username)
	if err != nil {
		log.Println(err)
		http.Redirect(w, r, server.Config.LoginPage, 303)
		return
	}
	s.SetCookie(w)
	http.Redirect(w, r, server.Config.MainPage, 303)
}
예제 #2
0
파일: main.go 프로젝트: AaronO/lightwave
func signupHandler(w http.ResponseWriter, r *http.Request) {
	// Determine the virtual host
	server, err := findServer(r.Host)
	if err != nil {
		errorHandler(w, r, err.String())
		return
	}

	username := r.FormValue("username")
	password := r.FormValue("password")
	email := r.FormValue("email")
	nickname := r.FormValue("nickname")

	log.Println("Register:", username)
	user, err := server.UserAccountDatabase.SignUpUser(email, nickname, username, password)
	if err != nil {
		log.Println(err)
		http.Redirect(w, r, server.Config.SignupPage, 303)
		return
	}
	s, err := server.SessionDatabase.CreateSession(user.Username)
	if err != nil {
		log.Println(err)
		http.Redirect(w, r, server.Config.LoginPage, 303)
		return
	}
	s.SetCookie(w)
	http.Redirect(w, r, server.Config.MainPage, 303)
}
예제 #3
0
파일: fetch.go 프로젝트: qtse/go_fetch
func c1LoginHandler(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	if l, err := c1IsLoggedIn(c); err != nil {
		http.Error(w, err.String(), http.StatusInternalServerError)
		return
	} else if l {
		///    http.Redirect(w, r, "/", http.StatusFound)
		http.Redirect(w, r, "/index", http.StatusFound)
		return
	}

	if r.Method == "GET" {
		w.Write([]byte(
			"<html><body><form action='/c1Login' method='POST'>" +
				"<input type='text' name='usr'></input>" +
				"<input type='password' name='pwd'></input>" +
				"<input type='submit' value='Submit'></input>" +
				"</form></body></html>"))
		return
	} else if r.Method == "POST" {
		usr := r.FormValue("usr")
		pwd := r.FormValue("pwd")
		_, err := C1Login(c, usr, pwd)
		if err == C1AuthError {
			http.Error(w, err.String(), http.StatusUnauthorized)
			return
		}
		http.Redirect(w, r, "/index", http.StatusFound)
		///    http.Redirect(w, r, "/", http.StatusFound)
	}
}
예제 #4
0
파일: godoc.go 프로젝트: WXB506/golang
func serveFile(w http.ResponseWriter, r *http.Request) {
	relpath := r.URL.Path[1:] // serveFile URL paths start with '/'
	abspath := absolutePath(relpath, *goroot)

	// pick off special cases and hand the rest to the standard file server
	switch r.URL.Path {
	case "/":
		serveHTMLDoc(w, r, filepath.Join(*goroot, "doc", "root.html"), "doc/root.html")
		return

	case "/doc/root.html":
		// hide landing page from its real name
		http.Redirect(w, r, "/", http.StatusMovedPermanently)
		return
	}

	switch path.Ext(relpath) {
	case ".html":
		if strings.HasSuffix(relpath, "/index.html") {
			// We'll show index.html for the directory.
			// Use the dir/ version as canonical instead of dir/index.html.
			http.Redirect(w, r, r.URL.Path[0:len(r.URL.Path)-len("index.html")], http.StatusMovedPermanently)
			return
		}
		serveHTMLDoc(w, r, abspath, relpath)
		return

	case ".go":
		serveTextFile(w, r, abspath, relpath, "Source file")
		return
	}

	dir, err := fs.Lstat(abspath)
	if err != nil {
		log.Print(err)
		serveError(w, r, relpath, err)
		return
	}

	if dir != nil && dir.IsDirectory() {
		if redirect(w, r) {
			return
		}
		if index := filepath.Join(abspath, "index.html"); isTextFile(index) {
			serveHTMLDoc(w, r, index, relativeURL(index))
			return
		}
		serveDirectory(w, r, abspath, relpath)
		return
	}

	if isTextFile(abspath) {
		serveTextFile(w, r, abspath, relpath, "Text file")
		return
	}

	fileServer.ServeHTTP(w, r)
}
예제 #5
0
func searchHandler(w http.ResponseWriter, r *http.Request) {
	context := &Search{}
	// prepare the template
	t, err := template.ParseFile("template/search.html")
	if err != nil {
		http.Error(w, err.String(), http.StatusInternalServerError)
	}
	context.T = t
	ae := appengine.NewContext(r)
	query := r.FormValue("q")
	queryLength := len([]int(query)) // unicode length
	// max 8 letters
	if queryLength > 8 {
		query = query[0:8]
		http.Redirect(w, r, fmt.Sprintf("search?q=%s", query), 302)
		return
	}
	// lowercase only
	if query != strings.ToLower(query) {
		http.Redirect(w, r, fmt.Sprintf("search?q=%s", strings.ToLower(query)), 302)
		return
	}
	context.Q = query

	hashTable := make(map[string]byte, 0)

	if 0 != queryLength {
		if queryLength > 8 {
			query = query[0:8]
		}
		// make sure enable is loaded
		var e *word.Enable
		var err os.Error
		if e, err = loadEnable(); err != nil {
			ae.Errorf("%v", err)
		}
		channel := word.StringPermutations(query)
		for p := range channel {
			if valid := e.WordIsValid(p); !valid {
				continue
			}
			if _, inHash := hashTable[p]; !inHash {
				context.Permutations = append(context.Permutations, p)
				hashTable[p] = 1
			}
		}
	}
	// display template
	if err := context.T.Execute(w, context); err != nil {
		http.Error(w, err.String(), http.StatusInternalServerError)
	}
}
예제 #6
0
파일: add-event.go 프로젝트: Epictetus/wfdr
func SaveHandler(c http.ResponseWriter, r *http.Request) {
	fmt.Println(r)
	title, id, origID, dateString, desc, body, fileName, importance, delete := HandleNess(c, r)

	date, e := time.Parse(timeFormat, string(dateString))

	event := new(Event)

	// The ID changed, remove the old one.
	if !bytes.Equal(id, origID) && len(origID) > 0 {
		fmt.Println("ID Changed!")
		origEvent := new(Event)
		origEvent.ID = string(origID)
		origEvent.Load()

		// Copy the info to the new event
		*event = *origEvent

		origEvent.Delete()
	}

	event.ID = string(id)
	event.Load()

	// TODO: Delete the uploaded image as well!
	if delete {
		event.Delete()
		http.Redirect(c, r, "/events", 301)
		return
	}

	event.Importance = importance
	event.Title = string(title)
	event.Desc = string(desc)
	event.Link = "/events/" + string(id)
	event.Time = (*Time)(date)
	if len(fileName) > 0 {
		event.Img = "/img/events/data/" + fileName
	}

	e = pages.SavePage("events/"+string(id), body, title)

	event.Save()

	fmt.Println(title, id, dateString, date, e, desc, body)
	fmt.Println(r.FormValue("img"))

	http.Redirect(c, r, "/events/"+event.ID, 301)
}
예제 #7
0
func handleUpload(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	blobs, _, err := blobstore.ParseUpload(r)
	if err != nil {
		serveError(c, w, err)
		return
	}
	file := blobs["file"]
	if len(file) == 0 {
		c.Errorf("no file uploaded")
		http.Redirect(w, r, "/", http.StatusFound)
		return
	}
	http.Redirect(w, r, "/serve/?blobKey="+string(file[0].BlobKey), http.StatusFound)
}
예제 #8
0
파일: picasa.go 프로젝트: Epictetus/wfdr
// For login authentication from picasa.
// TODO: Add error handling.
func AuthHandler(c http.ResponseWriter, r *http.Request) {
	// Get the token supplied in the URL.
	picasaLen := len("token=")
	url, _ := http.URLUnescape(r.URL.RawQuery)
	token := url[picasaLen:]
	fmt.Println(token, r.URL.RawQuery)

	// Try to upgrade the token to a multi-use one. See
	// http://code.google.com/apis/accounts/docs/AuthSub.html
	req := picasa.NewRequest("https://www.google.com/accounts/accounts/AuthSubSessionToken", token, "GET")
	resp, e := picasa.Send(req)

	// Get the upgraded token value
	body, e := ioutil.ReadAll(resp.Body)
	if e != nil {
		fmt.Println(e)
	}
	resp.Body.Close()
	if len(body) <= picasaLen {
		dlog.Println("Invalid or missing token! Response received was:", body)
		template.Error500(c, r, nil)
	}
	upgradedToken := body[picasaLen:]
	fmt.Println("Upgraded Token: ", string(upgradedToken))

	// Finally, save the upgraded token in the server-side session.
	u, _ := user.Get(c, r)
	u.Set("picasa-authsub-token", string(upgradedToken))
	http.Redirect(c, r, "/photos/upload", http.StatusFound)
}
예제 #9
0
파일: godoc.go 프로젝트: WXB506/golang
func redirect(w http.ResponseWriter, r *http.Request) (redirected bool) {
	if canonical := path.Clean(r.URL.Path) + "/"; r.URL.Path != canonical {
		http.Redirect(w, r, canonical, http.StatusMovedPermanently)
		redirected = true
	}
	return
}
func handleLogout(w http.ResponseWriter, r *http.Request) {
	c = appengine.NewContext(r)
	returnURL := "/"
	// parse form
	err := r.ParseForm()
	if err != nil {
		serveError(c, w, err)
		return
	}
	if r.FormValue("continue") != "" {
		returnURL = r.FormValue("continue")
	}

	if useOpenID {
		// adjust returnURL to bring us back to a local user login form
		laterReturnUrl := returnURL
		returnURL = "/Login/?chooseLogin=1&continue=" + http.URLEscape(laterReturnUrl)
	}
	// redirect to google logout (for OpenID as well, or else we won't be locally logged out)
	lourl, err := user.LogoutURL(c, returnURL)
	if err != nil {
		c.Errorf("handleLogout: error getting LogoutURL")
	}
	c.Debugf("handleLogout: redirecting to logoutURL=%v", lourl)
	http.Redirect(w, r, lourl, http.StatusFound)
	return
}
예제 #11
0
func addWidget(w http.ResponseWriter, r *http.Request) {
	var err os.Error
	if fixup == nil {
		fixup, err = regexp.Compile(`[^A-Za-z0-9\-_. ]`)
		if err != nil {
			http.Error(w, err.String(), http.StatusInternalServerError)
			return
		}
	}

	ctx := appengine.NewContext(r)
	name := fixup.ReplaceAllString(r.FormValue("name"), "")

	if len(name) == 0 {
		http.Error(w, "Invalid/no name provided", http.StatusInternalServerError)
		return
	}

	widget := NewWidget(ctx, name)

	err = widget.Commit()
	if err != nil {
		http.Error(w, err.String(), http.StatusInternalServerError)
		return
	}

	http.Redirect(w, r, "/widget/list", http.StatusFound)
}
예제 #12
0
func saveHandler(w http.ResponseWriter, r *http.Request) {
	title := r.URL.Path[lenPath:]
	body := r.FormValue("body")
	p := &Page{Title: title, Body: []byte(body)}
	p.save()
	http.Redirect(w, r, "/view/"+title, http.StatusFound)
}
예제 #13
0
파일: GameOfLife.go 프로젝트: josejc/life
//This is what sends the Post data to the primarry "run" function
func handleTest(writer http.ResponseWriter, request *http.Request) {
	BoardSize, _ := strconv.Atoi(request.FormValue("BoardSize"))
	NumberThreads, _ := strconv.Atoi(request.FormValue("NumberThreads"))
	NumberIterations, _ := strconv.Atoi(request.FormValue("NumberIterations"))
	run(writer, BoardSize, NumberThreads, NumberIterations)
	http.Redirect(writer, request, "/", http.StatusFound)
}
예제 #14
0
파일: twitter.go 프로젝트: licio/unico
func signInTwitterHandler(w http.ResponseWriter, r *http.Request) {

	c := appengine.NewContext(r)
	id := r.FormValue("id")
	if id == "" {
		serveError(c, w, os.NewError("Missing ID parameter"))
		return
	}

	conf := &tweetlib.Config{
		ConsumerKey:    appConfig.TwitterConsumerKey,
		ConsumerSecret: appConfig.TwitterConsumerSecret,
		Callback:       "http://" + appConfig.AppHost + "/twitter?action=temp&id=" + id}
	tok := &tweetlib.Token{}
	tr := &tweetlib.Transport{Config: conf,
		Token:     tok,
		Transport: &urlfetch.Transport{Context: c}}

	tt, err := tr.TempToken()
	if err != nil {
		c := appengine.NewContext(r)
		serveError(c, w, err)
		c.Errorf("%v", err)
		return
	}
	item := &memcache.Item{
		Key:   tt.Token,
		Value: []byte(tt.Secret),
	}
	// Add the item to the memcache, if the key does not already exist
	memcache.Add(c, item)

	http.Redirect(w, r, tt.AuthURL(), http.StatusFound)
}
예제 #15
0
파일: camweb.go 프로젝트: marsch/camlistore
func mainHandler(rw http.ResponseWriter, req *http.Request) {
	relPath := req.URL.Path[1:] // serveFile URL paths start with '/'
	if strings.Contains(relPath, "..") {
		return
	}

	if strings.HasPrefix(relPath, "gw/") {
		path := relPath[3:]
		http.Redirect(rw, req, "/code/?p=camlistore.git;f="+path+";hb=master", http.StatusFound)
		return
	}

	absPath := path.Join(*root, "content", relPath)
	fi, err := os.Lstat(absPath)
	if err != nil {
		log.Print(err)
		serveError(rw, req, relPath, err)
		return
	}
	if fi.IsDirectory() {
		relPath += "/index.html"
		absPath = path.Join(*root, "content", relPath)
		fi, err = os.Lstat(absPath)
		if err != nil {
			log.Print(err)
			serveError(rw, req, relPath, err)
			return
		}
	}

	switch {
	case fi.IsRegular():
		serveFile(rw, req, relPath, absPath)
	}
}
예제 #16
0
파일: main.go 프로젝트: Epictetus/wfdr
func AuthHandler(c http.ResponseWriter, r *http.Request) {
	var o = new(openid.OpenID)
	o.ParseRPUrl(r.RawURL)
	grant, e := o.Verify()
	if e != nil {
		emsg := fmt.Sprintln("Error in openid auth handler:", e)
		fmt.Println(emsg)
		fmt.Fprintln(c, emsg)
		return
	}
	if !grant {
		fmt.Println("Permission denied!")
		fmt.Fprintln(c, "Access denied by user or internal error.")
		return
	}
	s := session.Get(c, r)
	fmt.Println("Permission granted!")
	fmt.Println(o)
	wantedValues := []string{"value.email", "value.first", "value.last", "value.country", "value.lang"}
	for _, wantedValue := range wantedValues {
		value, _ := http.URLUnescape(o.Params["openid.ext1."+wantedValue])
		s.Set("openid-"+wantedValue[len("value."):], value)
	}
	id, _ := http.URLUnescape(o.Params["openid.ext1.value.email"])
	continueURL := s.Get("openid-continue-url")
	if continueURL == "" {
		continueURL = "/"
	}
	fmt.Println(c, r, continueURL)
	http.Redirect(c, r, continueURL, 307)
	fmt.Fprintln(c, "Authenticated as", id)
	return
}
예제 #17
0
func TWITTER_REPLIES(c *http.Conn, req *http.Request) {
	log.Stderrf(">REPLIES:");
	s := session_service.GetSession(c,req);
	for k,v := range s.Data {
		log.Stderrf("session kv:%s:%s", k, v);
	}
	auth_token, atx := s.Data["oauth_token"];
	if atx {
		log.Stderrf("TOKEN FOUND!");
		auth_token_secret := s.Data["oauth_token_secret"];
		r, finalUrl, err := twitter_client.MakeRequest("http://twitter.com/statuses/mentions.json", map[string]string{"oauth_token":auth_token}, auth_token_secret, false); //{"since_id":s.last_reply_id})
		if err != nil {
			log.Stderrf(":REPLIES:err:%s",err);
		}
		else {
			log.Stderrf(":REPLIES:r:%s:finalUrl:%s", r, finalUrl);
			b, _ := io.ReadAll(r.Body);
			print ("REPLIES!");
			str := bytes.NewBuffer(b).String();
       			println (str);
			j, ok, errtok := json.StringToJson(str);
			log.Stderr("REPLIES:j:%s:ok:%s:errtok:%s", j, ok, errtok);
			c.Write(strings.Bytes(j.String()));
		}
	
	}
	else {
		log.Stderrf("NO TOKEN FOUND!");
		http.Redirect(c, "/login/twitter?returnto=/twitter/replies", http.StatusFound); // should be 303 instead of 302?
	}
}
예제 #18
0
파일: main.go 프로젝트: AaronO/lightwave
func fileHandler(w http.ResponseWriter, r *http.Request) {
	// Determine the virtual host
	server, err := findServer(r.Host)
	if err != nil {
		errorHandler(w, r, err.String())
		return
	}
	// log.Println("URI is ", "/_static" + r.URL.Path)
	// Parse the URI, prepend "/_static"
	uri, ok := lightwave.NewURI("/_static" + r.URL.Path)
	if !ok {
		errorHandler(w, r, "Error parsing URI")
		return
	}
	// GET handler
	if r.Method != "GET" {
		errorHandler(w, r, "Unsupported HTTP method")
	}

	// Requests for the application page are redirected to the login page
	if r.URL.Path == server.Config.MainPage {
		// Find the session
		_, err := server.SessionDatabase.FindSession(r)
		if err != nil {
			http.Redirect(w, r, server.Config.LoginPage, 303)
			return
		}
	}

	ch := make(chan bool)
	req := &lightwave.GetRequest{lightwave.Request{w, r.URL.RawQuery, ch, lightwave.ClientOrigin, uri, nil}}
	server.Get(req)
	<-ch
}
예제 #19
0
파일: gopasty.go 프로젝트: roxtar/gopasty
func HandleNewPaste(writer http.ResponseWriter, request *http.Request) {
	err := request.ParseForm()
	if err != nil {
		write_error(writer, err)
		return
	}
	text := request.FormValue("paste_text")
	language := request.FormValue("language")

	var page *Page
	page, err = NewPage(text, language)

	if err != nil {
		write_error(writer, err)
		return
	}
	// check if we already have a page
	// and not store it again
	oldpage, err := GetPageFromDataStore(page.UrlId, request)
	if oldpage == nil {
		err = StorePage(page, request)
		if err != nil {
			write_error(writer, err)
			return
		}
	}
	http.Redirect(writer, request, "/"+page.UrlId[0:LENGTH], http.StatusFound)
}
예제 #20
0
파일: unico.go 프로젝트: licio/unico
func deleteAccountHandler(w http.ResponseWriter, r *http.Request) {

	id := ""
	session, err := sessions.Session(r, "", "datastore")
	c1 := appengine.NewContext(r)
	c1.Debugf("deleteAccount: id=%v, session=%v, err=%v\n", session["userID"], session, err)
	if err == nil {
		if session["userID"] != nil {
			id = session["userID"].(string)
		}
	}
	if id != "" {
		user := loadUser(r, id)
		if user.Id != "" {
			c := appengine.NewContext(r)
			key := datastore.NewKey(c, "User", user.Id, 0, nil)
			datastore.Delete(c, key)
			session["userID"] = ""
			sessions.Save(r, w)
			memUserDelete(c, user.Id)
			memcache.Delete(c, "user"+user.Id)
			http.SetCookie(w, &http.Cookie{Name: "userId", Value: "", Domain: appConfig.AppDomain, Path: "/", MaxAge: -1})
		}
	}
	http.Redirect(w, r, "/", http.StatusFound)
}
예제 #21
0
func init() {
	fmt.Println("Selog filekkkk")
	http.Handle("/index", http.HandlerFunc(Render))
	http.Handle("/index.ghtml", http.HandlerFunc(RenderGoPagesForbidden))

	http.Handle("/", http.HandlerFunc(func(conn http.ResponseWriter, request *http.Request) {
		if request.URL.Path == "/" {
			defaultPage := "index"
			if strings.TrimSpace(defaultPage) != "" {
				http.Redirect(conn, defaultPage, 307)
			}
			return
		}
		val := "src" + request.URL.Path
		input, err := os.OpenFile(val, os.O_RDONLY, 0666)
		//		input,err := os.Open(val)
		if err != nil {
			conn.WriteHeader(404)
			conn.Write([]byte("<h1>404 Not Found</h1>"))
			return
		}
		s, _ := input.Stat()
		conn.Header.Set("Content-Length", fmt.Sprintf("%d(MISSING)", s.Size))
		//	conn.SetHeader("Content-Type", mime.TypeByExtension(strings.ToLower(path.Ext(val))))
		fmt.Sprintf("%d(MISSING)", s.Size)
		mime.TypeByExtension(strings.ToLower(path.Ext(val)))

		conn.WriteHeader(200)
		http.ServeFile(conn, request, val)
	}))
	http.Handle("/src", http.HandlerFunc(RenderGoPagesForbidden))
	http.Handle("/pages", http.HandlerFunc(RenderGoPagesForbidden))

}
예제 #22
0
// receives ?returnto=/replies etc.
func CALLBACK(c *http.Conn, req *http.Request, auth_client *oauth.AuthClient) {
	log.Stderr("CALLBACK!");
	req.ParseForm();
	for k,v := range req.Header {
		log.Stderrf("header:%s:%s", k, v);
	}
	for k,vs := range req.Form {
		log.Stderrf("form:%s::", k);
		for i := range vs {
			log.Stderrf("::%s", vs[i]);
		}
	}

	var auth_token = req.FormValue("oauth_token");
	var auth_verifier = req.FormValue("oauth_verifier");
	log.Stderrf("CALLBACK:auth_token:%s:", auth_token);
	log.Stderrf("CALLBACK:auth_verifier:%s:", auth_verifier);

	user_info := auth_client.GetUserInfo(auth_token, auth_verifier);

	log.Stderrf("USER_INFO:");
	for k,v := range user_info {
		log.Stderrf("k:%s v:%s", k, v);
	}

	session_service.StartSession(c, req, user_info);
	var url = "/";
	returnto := req.FormValue("returnto");
	if returnto != "" {
		url = returnto;
	}
	http.Redirect(c, url, http.StatusFound); // should be 303 instead of 302?
}
예제 #23
0
파일: app.go 프로젝트: cyberkni/whosonit
func accept_event(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	event, key, err_string := find_single_event(c, r.FormValue("sender"),
		r.FormValue("date"))

	if len(err_string) > 0 {
		fmt.Fprintf(w, err_string)
		return
	}
	if event.OwnerDate > 0 {
		fmt.Fprintf(w, "This message is already owned by %s.", event.Owner)
		return
	}
	event.OwnerDate = datastore.SecondsToTime(time.Seconds())
	event.Owner = "Someone"
	_, err := datastore.Put(c, key, &event)
	if err != nil {
		fmt.Fprintf(w, err.String())
		return
	} else {
		target_url := fmt.Sprintf("/show?sender=%s&date=%d", event.Sender,
			event.RecieptDate)
		http.Redirect(w, r, target_url, http.StatusFound)
	}
}
예제 #24
0
func get(w http.ResponseWriter, r *http.Request) {
	if r.URL.Path == "/" {
		http.Redirect(w, r, WEBSITE, http.StatusFound)
		return
	}
	parts := strings.Split(r.URL.Path, "/")
	if len(parts) == 3 {
		if key := parts[1]; key != "" {
			blobKey := appengine.BlobKey(key)
			bi, err := blobstore.Stat(appengine.NewContext(r), blobKey)
			if err == nil {
				w.Header().Add(
					"Cache-Control",
					fmt.Sprintf("public,max-age=%d", EXPIRATION_TIME),
				)
				if imageTypes.MatchString(bi.ContentType) {
					w.Header().Add("X-Content-Type-Options", "nosniff")
				} else {
					w.Header().Add("Content-Type", "application/octet-stream")
					w.Header().Add(
						"Content-Disposition:",
						fmt.Sprintf("attachment; filename=%s;", parts[2]),
					)
				}
				blobstore.Send(w, appengine.BlobKey(key))
				return
			}
		}
	}
	http.Error(w, "404 Not Found", http.StatusNotFound)
}
예제 #25
0
파일: app.go 프로젝트: cyberkni/whosonit
func close_event(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	event, key, err_string := find_single_event(c, r.FormValue("sender"),
		r.FormValue("date"))

	if len(err_string) > 0 {
		fmt.Fprintf(w, err_string)
		return
	}
	// TODO: Check to make sure the closer matches the owner
	if event.ClosedDate > 0 {
		fmt.Fprintf(w, "This message is already closed.")
		return
	}
	event.ClosedDate = datastore.SecondsToTime(time.Seconds())
	_, err := datastore.Put(c, key, &event)
	if err != nil {
		fmt.Fprintf(w, err.String())
		return
	} else {
		target_url := fmt.Sprintf("/show?sender=%s&date=%d", event.Sender,
			event.RecieptDate)
		http.Redirect(w, r, target_url, http.StatusFound)
	}
}
예제 #26
0
파일: gotoserver.go 프로젝트: robfig/goto
func handle(w http.ResponseWriter, r *http.Request) {
	// If root, show the link registration page.
	if r.URL.Path == "/" {
		switch r.Method {
		case "GET":
			w.Write([]byte(registration))

		case "POST":
			// Get input
			key := r.FormValue("key")
			url := r.FormValue("url")

			// Write to db
			resp := make(chan bool)
			save <- SaveRequest{key, url, resp}
			_ = <-resp
			w.Write([]byte("ok"))
		}
		return
	}

	// Redirect user based on the path.
	resp := make(chan string)
	code := r.URL.Path[1:]
	lookup <- LookupRequest{code, resp}
	url := <-resp
	if url == "" {
		http.Error(w, "Key not found", http.StatusNotFound)
		return
	}
	http.Redirect(w, r, <-resp, http.StatusFound)
}
예제 #27
0
파일: google.go 프로젝트: licio/unico
func loginGoogle(w http.ResponseWriter, r *http.Request) {
	tr := emptyTransport()
	c := appengine.NewContext(r)
	tr.Transport = &urlfetch.Transport{Context: c}
	urls := tr.AuthCodeURL("login") + "&approval_prompt=force&access_type=offline"
	http.Redirect(w, r, urls, http.StatusFound)
}
예제 #28
0
func redirect(c *http.Conn, r *http.Request) (redirected bool) {
	if canonical := pathutil.Clean(r.URL.Path) + "/"; r.URL.Path != canonical {
		http.Redirect(c, canonical, http.StatusMovedPermanently)
		redirected = true
	}
	return
}
예제 #29
0
func saveHandler(w http.ResponseWriter, r *http.Request) {
	title, err := getTitle(w, r)
	if err != nil {
		return
	}
	body := r.FormValue("body")
	tags := r.FormValue("tags")

	m, err2 := Load(tagsPath + tagsFile)
	if err2 != nil {
		return

	}
	splitTokens := strings.Split(tags, " ", -1)
	for i := 0; i < len(splitTokens); i++ {
		Add(m, splitTokens[i], title)
	}

	err2 = Store(m, tagsPath+tagsFile)
	if err2 != nil {
		return
	}

	p := &Page{Title: title, Body: []byte(body)}
	err = p.save()
	if err != nil {
		http.Error(w, err.String(), http.StatusInternalServerError)
		return
	}
	http.Redirect(w, r, view+title, http.StatusFound)
}
func register(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	g := Member{
		Usern:    r.FormValue("usern"),
		Name:     r.FormValue("name"),
		Passwd:   r.FormValue("passwd"),
		Repasswd: r.FormValue("repasswd"),
		Phone:    r.FormValue("phone"),
		Email:    r.FormValue("email"),
		Study:    r.FormValue("study"),
		Address:  r.FormValue("address"),
		Date:     datastore.SecondsToTime(time.Seconds()),
	}

	if g.Passwd == g.Repasswd && g.Usern != "" && g.Name != "" && g.Phone != "" && g.Email != "" {
		_, err := datastore.Put(c, datastore.NewIncompleteKey("Member"), &g)

		if err != nil {
			http.Error(w, err.String(), http.StatusInternalServerError)
			return
		}

	} else {
		http.Redirect(w, r, "/signin", http.StatusFound)
	}
	http.Redirect(w, r, "/view", http.StatusFound)
}