Golang appengine-datastore.SecondsToTime类(方法)实例源码

// 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 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)
	}
}

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

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

// 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)
}

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

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

// 勉強会の追加
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
}

func NewCharge(userKey *datastore.Key) *Charge {
	return &Charge{
		datastore.SecondsToTime(time.Seconds()),
		userKey,
		0,
		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
}

// 勉強会の更新
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
}

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
}

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

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
}

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
}

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

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

/**
 * 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
}