Exemplo n.º 1
0
// Set Value From HTMLForm Values
func (t *Tasks) SetValue(Id string, r *http.Request) os.Error {

	var err os.Error

	t.UserId = Id
	t.KeyID, err = strconv.Atoi64(r.FormValue(FORM_KEY))
	if err != nil {
		t.KeyID = 0
	}
	t.Status, err = strconv.Atoi(r.FormValue(FORM_STATUS))
	if err != nil {
		log.Println(err)
		return err
	}

	log.Println("Status")

	t.Context = html.EscapeString(r.FormValue(FORM_CONTEXT))
	t.IsUseLimit, err = strconv.Atob(r.FormValue(FORM_LIMIT))
	if err != nil {
		log.Println(err)
		return err
	}

	log.Println("IsUseLimit")

	t.IsComplete = (t.Status == 2)
	t.IsCanceld = (t.Status == 9)

	log.Println("Set Bool Value")

	if t.IsUseLimit {

		log.Println(r.FormValue(FORM_DATE))
		log.Println(time.RFC3339)
		var limit *time.Time
		limit, err = time.Parse("2006-01-02 15:04:05", r.FormValue(FORM_DATE))
		if err == nil {
			t.PlanDate = datastore.SecondsToTime(limit.Seconds())
		} else {
			log.Println(err)
			return err
		}
	}

	log.Println("PostDate")
	t.PostDate = datastore.SecondsToTime(time.Seconds())
	if t.IsComplete {
		t.CompleteDate = datastore.SecondsToTime(time.Seconds())
	}

	return 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
	}

}
Exemplo n.º 3
0
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)
	}
}
Exemplo n.º 4
0
// articlePost handles saving new/edited pages in the admin manager. It
// generates the Article struct based on data submitted by the client, and
// then puts it into the datastore.
// TODO: Don't need to manually delete old instance, can simply replace it,
// so skip that step!
func articlePost(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	// Create the article struct based on form data
	a := Article{
		ID:        r.FormValue("OldID"), // This may or may not be blank
		Title:     r.FormValue("Title"),
		Author:    user.Current(c).String(),
		Date:      datastore.SecondsToTime(time.Seconds()),
		Public:    true, // TODO: Implement public/private
		ShortBody: []byte(r.FormValue("ShortBody")),
		Body:      []byte(r.FormValue("Body")),
	}
	a.DisplayDate = a.Date.Time().Format("Jan 2") // Set exposed date

	// If a.ID isn't blank, that means we're updating an article
	if a.ID != "" {
		// TODO: Need to remove the delete, and verify things still work
		err := datastore.Delete(c, datastore.NewKey(c, "Article",
			a.ID, 0, nil))
		check(err)
	} else {
		a.ID = newArticleID()
	}

	// Add the Article struct to the datastore
	_, err := datastore.Put(c, datastore.NewKey(c, "Article",
		a.ID, 0, nil), &a)
	check(err)

	// Prints the article back to the client upon access (should come up with
	// a better way to express success!)
	fmt.Fprintf(w, "Article: %v\n", a)
}
Exemplo n.º 5
0
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)
	}
}
Exemplo n.º 6
0
func gamesPost(w http.ResponseWriter, r *http.Request, u *user.User, c appengine.Context) {

	game := Game{
		P1:     r.FormValue("player1"),
		P2:     r.FormValue("player2"),
		Played: datastore.SecondsToTime(time.Seconds()),
	}
	scorefields := map[string]int{
		"Player1score": 0,
		"Player2score": 0,
	}
	for k, _ := range scorefields {
		score, err := strconv.Atoi(r.FormValue(k))
		if err != nil {
			http.Error(w, err.String(), http.StatusInternalServerError)
			return
		}
		scorefields[k] = score
	}
	game.P1score = scorefields["Player1score"]
	game.P2score = scorefields["Player2score"]

	_, err := datastore.Put(c, datastore.NewIncompleteKey("Game"), &game)
	if err != nil {
		http.Error(w, err.String(), http.StatusInternalServerError)
		return
	}

	rurl := fmt.Sprintf("http://%v/", r.Host)
	w.Header().Set("Location", rurl)
	w.WriteHeader(http.StatusFound)
}
Exemplo n.º 7
0
func postPosition(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	gid, _ := strconv.Atoi(r.FormValue("gid"))
	pid, _ := strconv.Atoi(r.FormValue("pid"))
	lat, _ := strconv.Atoi(r.FormValue("lat"))
	lng, _ := strconv.Atoi(r.FormValue("lng"))
	now := datastore.SecondsToTime(time.Seconds())

	go savePlayer(c, &Player{pid, gid, lat, lng, now})

	q := datastore.NewQuery("Player").
		Filter("GameId =", gid)
	players := make([]Player, 0, 10)
	for t := q.Run(c); ; {
		var p Player
		_, err := t.Next(&p)
		if err == datastore.Done {
			break
		}
		if err != nil {
			serveError(c, w, err)
			return
		}
		if p.PlayerId != pid {
			players = append(players, p)
		}
	}
	m := map[string]interface{}{"players": players, "dead": false}
	enc := json.NewEncoder(w)
	enc.Encode(m)
}
Exemplo n.º 8
0
// 勉強会の追加
func (group *Group) Add(c appengine.Context) os.Error {

	count := new(Counter)
	countKey := datastore.NewKey(c, "Counter", "mycounter", 0, nil)

	countErr := datastore.RunInTransaction(c, func(c appengine.Context) os.Error {
		err := datastore.Get(c, countKey, count)
		if err != nil && err != datastore.ErrNoSuchEntity {
			return err
		}

		count.GroupCount++

		_, err = datastore.Put(c, countKey, count)

		return err
	}, nil)

	if countErr != nil {
		return countErr
	}

	group.Id = count.GroupCount
	group.CreateDate = datastore.SecondsToTime(time.Seconds())

	key := datastore.NewKey(c, "Group", "", int64(group.Id), nil)

	_, err := datastore.Put(c, key, group)

	return err
}
Exemplo n.º 9
0
func NewCharge(userKey *datastore.Key) *Charge {
	return &Charge{
		datastore.SecondsToTime(time.Seconds()),
		userKey,
		0,
		0,
	}
}
Exemplo n.º 10
0
func (member *Member) Add(c appengine.Context) os.Error {
	parent := datastore.NewKey(c, "Group", "", int64(member.Id), nil)
	key := datastore.NewIncompleteKey(c, "Member", parent)

	member.CreateDate = datastore.SecondsToTime(time.Seconds())

	_, err := datastore.Put(c, key, member)

	return err
}
Exemplo n.º 11
0
func (a *ActDetail) toDS() (res *DSActDetail) {
	res = &DSActDetail{
		ActId:    a.ActId,
		Type:     a.Type,
		Name:     a.Name,
		Desc:     a.Desc,
		Location: a.Location,
		NCadets:  a.NCadets,
		NStaff:   a.NStaff,
	}
	if a.Start != nil {
		res.Start = datastore.SecondsToTime(a.Start.Seconds())
	}
	if a.End != nil {
		res.End = datastore.SecondsToTime(a.End.Seconds())
	}

	return
}
Exemplo n.º 12
0
// 勉強会の更新
func (group *Group) Put(c appengine.Context) os.Error {

	group.CreateDate = datastore.SecondsToTime(time.Seconds())

	key := datastore.NewKey(c, "Group", "", int64(group.Id), nil)

	_, err := datastore.Put(c, key, group)

	return err
}
Exemplo n.º 13
0
func addLinkHandler(w http.ResponseWriter, r *http.Request) {
	r.ParseForm()
	name := r.FormValue("name")
	url := r.FormValue("url")
	if !strings.HasPrefix(url, "http://") {
		url = "http://" + url
	}
	location := r.Header.Get("X-AppEngine-country")
	getStorage(r).Save(Linky{Name: name, URL: url, Location: location, Created: datastore.SecondsToTime(time.Seconds())})
	writeTemplate(w, MainPage, &PageModel{FooterMessage: "Link added", LinkyURL: r.Host + "/" + name, StatsURL: r.Host + "/stats/" + name, LinkyName: name})
}
Exemplo n.º 14
0
func (score *Score) Set(no int, name string, japanese, math, english int) {
	score.No = no
	score.Name = name
	score.Japanese = japanese
	score.Math = math
	score.English = english

	score.CreateDate = datastore.SecondsToTime(time.Seconds())

	// 格納されない値も計算
	score.Average = float32(japanese+math+english) / 3
}
Exemplo n.º 15
0
Arquivo: user.go Projeto: snim2/howl
func (huser *HowlUser) Create(context appengine.Context) (*datastore.Key, os.Error) {
	log.Println("Creating user profile for " + huser.Name + " with id " + huser.Uid)
	huser.Email = user.Current(context).Email
	huser.LastLogin = datastore.SecondsToTime(time.Seconds())
	huser.Streams = make([]*datastore.Key, 0, max_streams)
	huser.Providers = make([]*datastore.Key, 0, max_providers)
	huser.SharedStreams = make([]*datastore.Key, 0, max_shared_streams)
	huser.SharedProviders = make([]*datastore.Key, 0, max_shared_providers)
	key := datastore.NewKey("HowlUser", huser.Uid, 0, nil)
	err_s := "Error storing new user profile for " + huser.Uid
	return put(context, key, err_s, huser)
}
func LogAccess(r *http.Request, User string) (accessLog Access, err os.Error) {
	accessLog = Access{
		Date:          datastore.SecondsToTime(time.Seconds()),
		RemoteAddress: r.RemoteAddr,
		Method:        r.Method,
		URL:           r.RawURL,
		User:          User,
	}
	c := appengine.NewContext(r)

	_, err = datastore.Put(c, datastore.NewIncompleteKey("Access"), &accessLog)
	return // Access, err
}
Exemplo n.º 17
0
func input(w http.ResponseWriter, r *http.Request) {
    c := appengine.NewContext(r)

    var g Guest
    g.Name = r.FormValue("name")
    g.Date = datastore.SecondsToTime(time.Seconds())
    if _, err := datastore.Put(c, datastore.NewIncompleteKey(c, "Guest", nil), &g); err != nil {
        http.Error(w, err.String(), http.StatusInternalServerError)
        return
    }

    http.Redirect(w, r, "/", http.StatusFound)
}
Exemplo n.º 18
0
func handle_test_form(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	event := MailEvent{
		Body:        r.FormValue("Body"),
		Sender:      r.FormValue("Sender"),
		RecieptDate: datastore.SecondsToTime(time.Seconds()),
	}
	_, err := datastore.Put(c, datastore.NewIncompleteKey("Events"), &event)
	if err != nil {
		http.Error(w, err.String(), http.StatusInternalServerError)
		return
	}
	http.Redirect(w, r, "/", http.StatusFound)
}
Exemplo n.º 19
0
/**
 * Insert in datastore log
 *
 * @author A. Glansbeek en P. Kompier
 * @version 1.0
 * @date 2011-12-22
 * @param string de url
 * @param string de naam van wie url heeft aangeroepen
 * @param *http.Request
 * @return os.Error errors
 */
func SaveLog(url string, viewedby string, r *http.Request) os.Error {
	c := appengine.NewContext(r)

	pv := PageView{
		Page:     url,
		ViewedBy: viewedby,
		Date:     datastore.SecondsToTime(time.Seconds()),
	}

	// Record toevoegen aan de datastore
	_, err := datastore.Put(c, datastore.NewIncompleteKey(c, "PageView", nil), &pv)

	// Wanneer er een error optreedt deze terug geven
	return err
}
Exemplo n.º 20
0
func handleSign(r *web.Request) {
	c := gae.Context(r)
	g := &Greeting{
		Content: r.Param.Get("content"),
		Date:    datastore.SecondsToTime(time.Seconds()),
	}
	if u := user.Current(c); u != nil {
		g.Author = u.String()
	}
	if _, err := datastore.Put(c, datastore.NewIncompleteKey("Greeting"), g); err != nil {
		r.Error(web.StatusInternalServerError, err)
		return
	}
	r.Redirect("/", false)
}
func sign(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	g := Greeting{
		Content: r.FormValue("content"),
		Date:    datastore.SecondsToTime(time.Seconds()),
	}
	if u := user.Current(c); u != nil {
		g.Author = u.String()
	}
	_, err := datastore.Put(c, datastore.NewIncompleteKey(c, "Greeting", nil), &g)
	if err != nil {
		http.Error(w, err.String(), http.StatusInternalServerError)
		return
	}
	http.Redirect(w, r, "/", http.StatusFound)
}
Exemplo n.º 22
0
func post(w http.ResponseWriter, r *http.Request) {

	c := appengine.NewContext(r)
	g := Picture{
		Image: appengine.BlobKey(r.FormValue("picture")),
		Date:  datastore.SecondsToTime(time.Seconds()),
	}

	_, err := datastore.Put(c, datastore.NewIncompleteKey("Picture"), &g)
	if err != nil {
		http.Error(w, err.String(), http.StatusInternalServerError)
	}

	http.Redirect(w, r, "/", http.StatusFound)

}
func sign(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	g := Log{
		Content:       r.FormValue("content"),
		Date:          datastore.SecondsToTime(time.Seconds()),
		RemoteAddress: r.RemoteAddr,
	}
	g.User = requireAnyUser(w, r)

	_, err := datastore.Put(c, datastore.NewIncompleteKey("Log"), &g)
	if err != nil {
		http.Error(w, err.String(), http.StatusInternalServerError)
		return
	}

	http.Redirect(w, r, "/", http.StatusFound)
}
Exemplo n.º 24
0
// GetQuote retrieves the "ticker" data.
func GetQuote(c appengine.Context) (x xgen.Quote, err os.Error) {
	defer func() {
		if e, ok := recover().(os.Error); ok {
			err = e
		}
	}()
	var q Quote
	err = restapi.GetJson(c, JsonTicker, &q)
	check(err)
	x.Date = datastore.SecondsToTime(time.Seconds())
	x.HighestBuy = q.Ticker.Buy
	x.LowestSell = q.Ticker.Sell
	x.Last = q.Ticker.Last
	if !x.Validate() {
		panic("Invalid Ticker")
	}
	return
}
Exemplo n.º 25
0
func save(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	report := Report{
		Code: []byte(r.FormValue("code")),
		Opts: []byte(r.FormValue("data")),
		Date: datastore.SecondsToTime(time.Seconds()), // Now
	}

	key, err := datastore.Put(c, datastore.NewIncompleteKey(c, "report", nil), &report)
	if err != nil {
		c.Criticalf(err.String())
		renderTemplate(w, "500", nil)
		return
	}

	w.Header().Set("Location", "/reports/"+strconv.Itoa64(key.IntID()))
	w.WriteHeader(http.StatusFound)
}
Exemplo n.º 26
0
// Save saves the session in the response.
func (s *DatastoreSessionStore) Save(r *http.Request, w http.ResponseWriter,
	key string, info *sessions.SessionInfo) (flag bool, err error) {
	sid, serialized, error := getIdAndData(info)
	if error != nil {
		err = error
		return
	}

	// Save the session.
	c := appengine.NewContext(r)
	entityKey := datastore.NewKey(c, "Session", sessionKey(sid), 0, nil)
	_, err = datastore.Put(appengine.NewContext(r), entityKey, &Session{
		Date:  datastore.SecondsToTime(time.Seconds()),
		Value: serialized,
	})
	if err != nil {
		return
	}

	return sessions.SetCookie(s, w, key, cloneInfo(info, sid))
}
Exemplo n.º 27
0
func write(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		w.WriteHeader(http.StatusNotFound)
		w.Header().Set("Context-Type", "text/plain; charset=utf-8")
		fmt.Fprintf(w, "Not Found")
		return
	}

	c := appengine.NewContext(r)

	// DataStoreへの書き込み
	var g Guest
	g.Name = r.FormValue("name")
	g.Date = datastore.SecondsToTime(time.Seconds())

	if _, err := datastore.Put(c, datastore.NewIncompleteKey(c, "Guest", nil), &g); err != nil {
		http.Error(w, "Internal Server Error : "+err.String(), http.StatusInternalServerError)
		return
	}

	http.Redirect(w, r, "/", http.StatusFound)
}
Exemplo n.º 28
0
func add(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
	}

	f := Fact{
		Title:      r.FormValue("title"),
		Details:    r.FormValue("details"),
		SourceUrl:  r.FormValue("source_url"),
		SourceName: r.FormValue("source_name"),
		AddDate:    datastore.SecondsToTime(time.Seconds()),
		User:       u.String(),
	}
	key, err := datastore.Put(c, datastore.NewIncompleteKey(c, "Fact", nil), &f)
	if err != nil {
		http.Error(w, err.String(), http.StatusInternalServerError)
		return
	}

	tags := strings.Split(r.FormValue("tags"), ",")
	for _, t := range tags {
		t = strings.TrimSpace(t)
		t = strings.ToLower(t)
		fmt.Printf("<%q>\n", t)
		addTagToFact(c, key, t)
	}

	http.Redirect(w, r, "/", http.StatusFound)
}
Exemplo n.º 29
0
func upload(w http.ResponseWriter, r *http.Request, c appengine.Context, u *user.User) {
	templateContext := make(map[string]interface{})
	if r.Method != "POST" {
		templateContext["username"] = u.Email
		renderTemplate(w, "index", templateContext)
		return
	}

	comparison := new(Comparison)
	comparison.Title = r.FormValue("title")
	comparison.Left = extractImageFromPost("left_picture", r)
	comparison.Right = extractImageFromPost("right_picture", r)
	comparison.Submitter = u.Email
	comparison.Date = datastore.SecondsToTime(time.Seconds()) // now

	// Save the comparison under a unique key, a hash of the struct's data
	key := datastore.NewKey("Comparison", comparison.key(), 0, nil)
	_, err := datastore.Put(c, key, comparison)
	check(err)

	// Redirect to /edit using the key.
	http.Redirect(w, r, "/show/"+key.StringID(), 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)
}