コード例 #1
0
ファイル: BulletinBoard.go プロジェクト: SiroDiaz/csuf
func put(rw http.ResponseWriter, req *http.Request) {
	c := appengine.NewContext(req)
	u := user.Current(c)
	m := req.FormValue("message")
	s := req.FormValue("encoded_key")
	// fmt.Fprintf(rw, "Key 1: %v", s)
	p := req.FormValue("parent_key")
	var t, ut string
	var op bool
	var k *datastore.Key

	// make/decode keys
	if s == "" {
		if p == "" {
			k = datastore.NewIncompleteKey(c, "post", nil)
			op = true
		} else {
			pk, err := datastore.DecodeKey(p)
			if err != nil {
				http.Error(rw, err.Error(), http.StatusInternalServerError)
				return
			}
			k = datastore.NewIncompleteKey(c, "post", pk)
			op = false
		}
		t = time.Now().Format("Jan 2, 2006 3:04 PM")
		ut = ""
	} else {
		k, err := datastore.DecodeKey(s)
		if err != nil {
			http.Error(rw, err.Error(), http.StatusInternalServerError)
			return
		}
		mypost := Post{}
		err = datastore.Get(c, k, &mypost)
		if err != nil {
			http.Error(rw, err.Error(), http.StatusInternalServerError)
			return
		}
		ut = time.Now().Format("Jan 2, 2006 3:04 PM")
		t = mypost.PostDate
		op = mypost.OP
	}

	// data := url.Values{}
	// data.Set("encoded_key", k.Encode())

	// r, _ := http.NewRequest("POST", "/view", bytes.NewBufferString(data.Encode()))

	newpost := Post{Author: u.String(), Message: m, UpdateDate: ut, PostDate: t, OP: op}
	_, err := datastore.Put(c, k, &newpost)
	if err != nil {
		http.Error(rw, err.Error(), http.StatusInternalServerError)
		return
	}
	// http.Redirect(rw, r, "/view", http.StatusOK)
	http.Redirect(rw, req, "/", http.StatusTemporaryRedirect)
}
コード例 #2
0
ファイル: datastore.go プロジェクト: jward6/gopandemus
// SaveBoardState commits the state to the datastore
func SaveBoardState(c context.Context, state *BoardState) (*BoardState, error) {
	sessionKey, err := datastore.DecodeKey(state.SessionID)
	if err != nil {
		return nil, err
	}
	stateModel := &boardStateModel{}
	stateModel.parentKey = sessionKey
	stateModel.lastModified = time.Now()
	stateModel.key, err = datastore.Put(c, datastore.NewIncompleteKey(c, "BoardState", stateModel.parentKey), stateModel)
	if err != nil {
		return nil, err
	}

	// Initialize the result
	result := &BoardState{
		ID:           stateModel.key.Encode(),
		SessionID:    stateModel.parentKey.Encode(),
		LastModified: time.Now(),
		Players:      make(map[string]*Player),
	}

	// Save the players
	for k, v := range state.Players {
		p := &playerModel{
			Name:     k,
			Location: v.Location,
		}
		p.parentKey = stateModel.key
		p.key, err = datastore.Put(c, datastore.NewIncompleteKey(c, "PlayerState", p.parentKey), p)
		if err != nil {
			return nil, err
		}

		for _, card := range v.Hand {
			cardModel := &cardModel{
				Name:  card.Name,
				Color: card.Color,
			}
			cardModel.parentKey = p.key
			cardModel.key, err = datastore.Put(c, datastore.NewIncompleteKey(c, "PlayerCard", p.parentKey), cardModel)
			if err != nil {
				return nil, err
			}

		}

		// Added player to result
		result.Players[k] = &Player{
			Location: p.Location,
			Hand:     v.Hand,
		}
	}

	return result, nil
}
コード例 #3
0
func example6() {
	// [START parent]
	// Create Employee entity
	employee := &Employee{ /* ... */ }
	employeeKey, err := datastore.Put(ctx, datastore.NewIncompleteKey(ctx, "Employee", nil), employee)

	// Use Employee as Address entity's parent
	// and save Address entity to datastore
	address := &Address{ /* ... */ }
	addressKey := datastore.NewIncompleteKey(ctx, "Address", employeeKey)
	_, err = datastore.Put(ctx, addressKey, address)
	// [END parent]
	_ = err
}
コード例 #4
0
ファイル: main.go プロジェクト: Clarifai/kubernetes
// POST http://localhost:8080/profiles
// {"first_name": "Ivan", "nick_name": "Socks", "last_name": "Hawkes"}
//
func (u *ProfileApi) insert(r *restful.Request, w *restful.Response) {
	c := appengine.NewContext(r.Request)

	// Marshall the entity from the request into a struct.
	p := new(Profile)
	err := r.ReadEntity(&p)
	if err != nil {
		w.WriteError(http.StatusNotAcceptable, err)
		return
	}

	// Ensure we start with a sensible value for this field.
	p.LastModified = time.Now()

	// The profile belongs to this user.
	p.Email = user.Current(c).String()

	k, err := datastore.Put(c, datastore.NewIncompleteKey(c, "profiles", nil), p)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	// Let them know the location of the newly created resource.
	// TODO: Use a safe Url path append function.
	w.AddHeader("Location", u.Path+"/"+k.Encode())

	// Return the resultant entity.
	w.WriteHeader(http.StatusCreated)
	w.WriteEntity(p)
}
コード例 #5
0
//WriteLinkTweet writes a given Tweet to the datastore
func (mb MapBuilder) writeLinkTweet(tweets <-chan anaconda.Tweet, wg *sync.WaitGroup) {
	defer wg.Done()

	var keys []*datastore.Key
	var values []*int64

	for tweet := range tweets {
		key := datastore.NewIncompleteKey(mb.c, linkTweetKind, getTweetKey(mb.c))
		keys = append(keys, key)
		values = append(values, &tweet.Id)
	}

	err := datastore.RunInTransaction(mb.c, func(c context.Context) error {
		_, err := datastore.PutMulti(c, keys, values)

		if err != nil {
			log.Errorf(c, "Failed to write LinkTweet to datastore. %v", err.Error())
			return err
		}
		return nil
	}, nil)
	if err != nil {
		log.Errorf(mb.c, "Failed to write LinkTweet to datastore. %v", err.Error())
	}
}
コード例 #6
0
ファイル: hms.go プロジェクト: jordonwii/hms
func APIKeyAddHandler(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	u := user.Current(c)
	if u == nil {
		loginUrl, _ := user.LoginURL(c, r.URL.RequestURI())
		http.Redirect(w, r, loginUrl, http.StatusFound)
		return
	} else {
		if !u.Admin {
			w.WriteHeader(http.StatusForbidden)
			w.Write([]byte("You're not an admin. Go away."))
		} else {
			key := randomString(26)
			owner := r.FormValue("owner")

			if owner == "" {
				w.Write([]byte("You forgot a parameter."))
			} else {
				apiKey := APIKey{
					APIKey:     key,
					OwnerEmail: owner,
				}
				dkey := datastore.NewIncompleteKey(c, "APIKey", nil)
				_, err := datastore.Put(c, dkey, &apiKey)
				if err != nil {
					w.Write([]byte(fmt.Sprintf("error! %s", err.Error())))
				} else {
					w.Write([]byte(key))

				}
			}
		}
	}
}
コード例 #7
0
func warmupHandler(c *echo.Context) error {
	if appengine.IsDevAppServer() {
		photographers := []Photographer{
			{1, "Mr Canon"},
			{2, "Miss Nikon"},
			{3, "Mrs Pentax"},
			{4, "Ms Sony"},
		}

		// create some dummy data
		for m := 1; m <= 12; m++ {
			for d := 1; d < 28; d++ {
				taken := time.Date(2015, time.Month(m), d, 12, 0, 0, 0, time.UTC)
				id := rand.Int31n(4)
				photographer := photographers[id]
				p := Photo{
					Photographer: photographer,
					Uploaded:     time.Now().UTC(),
					Width:        8000,
					Height:       6000,
					Taken:        taken,
				}
				k := datastore.NewIncompleteKey(c, "photo", nil)
				nds.Put(c, k, &p)
			}
		}
	}
	return c.NoContent(http.StatusOK)
}
コード例 #8
0
ファイル: models.go プロジェクト: jordonwii/hms
func getOrCreateChat(c context.Context, fbChatID int64, keyBuf **datastore.Key) (*Chat, error) {
	results := make([]Chat, 0, 1)
	keys, err := datastore.NewQuery("Chat").
		Filter("FacebookChatID =", fbChatID).Limit(1).GetAll(c, &results)
	if err != nil {
		return nil, err
	}

	var resultChat *Chat
	var resultKey *datastore.Key

	if len(keys) == 0 {
		incKey := datastore.NewIncompleteKey(c, "Chat", nil)
		resultChat = &Chat{
			FacebookChatID: fbChatID,
			ChatName:       "",
		}
		resultKey, err = datastore.Put(c, incKey, resultChat)
		if err != nil {
			return nil, err
		}
	} else {
		resultKey = keys[0]
		resultChat = &results[0]
	}

	if keyBuf != nil {
		*keyBuf = resultKey
	}

	return resultChat, nil
}
コード例 #9
0
ファイル: venue.go プロジェクト: tgrosinger/mac-and-cheese
// CreateVenueHandler makes a new venue and saves it to the datastore
func CreateVenueHandler(w util.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	var venueData Venue
	if err := json.NewDecoder(r.Body).Decode(&venueData); err != nil {
		log.Println("Unable to decode create venue data:", err.Error())
		http.Error(w, "Unable to decode JSON request body", http.StatusBadRequest)
		return
	}

	if venueData.Name == "" {
		http.Error(w, `must provide "name" field when creating a venue`, http.StatusBadRequest)
		return
	}

	key := datastore.NewIncompleteKey(c, "Venues", nil)
	newKey, err := datastore.Put(c, key, &venueData)
	if err != nil {
		w.WriteJSON(nil, err)
		return
	}

	venueData.ID = newKey.IntID()
	w.WriteJSON(&venueData, nil)
}
コード例 #10
0
// this will generate some random data for the given day
// 24 * 12 on appengine (288)
// 24 only on development
func generateRandom(c context.Context, day time.Time) error {
	var x int
	if appengine.IsDevAppServer() {
		x = 1
	} else {
		x = 12
	}
	keys := make([]*datastore.Key, 24*x)
	photos := make([]*Photo, 24*x)

	id := 0
	for h := 0; h < 24; h++ {
		taken := day.Add(time.Duration(h) * time.Hour)
		for i := 0; i < x; i++ {
			photographer := photographers[rand.Int31n(4)]
			photos[id] = &Photo{
				Photographer: photographer,
				Uploaded:     time.Now().UTC(),
				Width:        8000,
				Height:       6000,
				Taken:        taken,
				TakenDay:     day,
			}
			keys[id] = datastore.NewIncompleteKey(c, "photo", nil)
			id++
		}
	}
	nds.PutMulti(c, keys, photos)
	return nil
}
コード例 #11
0
ファイル: submission_impl.go プロジェクト: pbochis/api
// Put will put this Submission into Datastore using the given key.
func (ƨ Submission) Put(ctx context.Context, key *datastore.Key) (*datastore.Key, error) {
	if key != nil {
		return datastore.Put(ctx, key, &ƨ)
	}

	return datastore.Put(ctx, datastore.NewIncompleteKey(ctx, "Submission", nil), &ƨ)
}
コード例 #12
0
ファイル: admin.go プロジェクト: dustin/sallingshome
func adminNewTask(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	asInt := func(s string) int {
		i, err := strconv.Atoi(s)
		if err != nil {
			panic(err)
		}
		return i
	}

	task := Task{
		Name:        r.FormValue("name"),
		Description: r.FormValue("description"),
		Assignee:    r.FormValue("assignee"),
		RType:       r.FormValue("rtype"),
		Automatic:   mightParseBool(r.FormValue("automatic")),
		Period:      asInt(r.FormValue("period")),
		Value:       asInt(r.FormValue("value")),
		Next:        time.Now().UTC(),
	}

	k, err := datastore.Put(c,
		datastore.NewIncompleteKey(c, "Task", nil), &task)
	if err != nil {
		log.Warningf(c, "Error storing task:  %v", err)
		panic(err)
	}
	log.Infof(c, "Stored new thing with key %v", k)

	http.Redirect(w, r, "/admin/tasks/", 307)
}
コード例 #13
0
ファイル: data.go プロジェクト: nick11roberts/SummerBootCamp
// insert tweet
func putTweet(req *http.Request, tweet *Tweet) error {
	ctx := appengine.NewContext(req)
	key := datastore.NewIncompleteKey(ctx, "Tweet", nil)
	_, err := datastore.Put(ctx, key, tweet)
	return err
	// you can use memcache also to improve your consistency
}
コード例 #14
0
ファイル: main.go プロジェクト: SiroDiaz/csuf
func create2Handler(w http.ResponseWriter, r *http.Request) {
	strTitle := r.FormValue("title")
	strLink := r.FormValue("link")
	//	fmt.Fprint(w, "go title: ", strTitle)
	//	fmt.Fprint(w, "link: ", strLink)

	//TODO error checking for the title and link

	c := appengine.NewContext(r)
	u := user.Current(c)

	//TODO error checking for user?

	//TODO check random thread against an already existing one
	rand.Seed(time.Now().UnixNano())
	newThreadId := rand.Int63()

	newSubmission := WebSubmission{
		Title:          strTitle,
		Link:           strLink,
		SubmitBy:       u.String(),
		Thread:         newThreadId, //TODO create random thread id
		SubmitDateTime: time.Now(),
		SubmissionDesc: "",
		Score:          0,
	}

	_, err := datastore.Put(c, datastore.NewIncompleteKey(c, WebSubmissionEntityName, nil), &newSubmission)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	http.Redirect(w, r, "/", http.StatusFound)
}
コード例 #15
0
ファイル: junit_test_result_impl.go プロジェクト: pbochis/api
// Put will put this JunitTestResult into Datastore using the given key.
func (ƨ JunitTestResult) Put(ctx context.Context, key *datastore.Key) (*datastore.Key, error) {
	if key != nil {
		return datastore.Put(ctx, key, &ƨ)
	}

	return datastore.Put(ctx, datastore.NewIncompleteKey(ctx, "JunitTestResult", nil), &ƨ)
}
コード例 #16
0
ファイル: gopherpods.go プロジェクト: rojters/gopherpods
func submitAddHandler(w http.ResponseWriter, r *http.Request) {
	ctx := appengine.NewContext(r)
	if err := r.ParseForm(); err != nil {
		serveErr(ctx, err, w)
		return
	}

	success, err := recaptchaCheck(ctx, r.FormValue("g-recaptcha-response"), r.RemoteAddr)
	if err != nil {
		serveErr(ctx, err, w)
		return
	}

	if !success {
		log.Warningf(ctx, "reCAPTCHA check failed")
		failedTmpl.ExecuteTemplate(w, "base", nil)
		return
	}

	sub := Submission{
		URL:       template.URL(strings.TrimSpace(r.FormValue("url"))),
		Submitted: time.Now(),
	}

	if _, err := datastore.Put(ctx, datastore.NewIncompleteKey(ctx, "Submission", nil), &sub); err != nil {
		serveErr(ctx, err, w)
		return
	}

	thanksTmpl.ExecuteTemplate(w, "base", nil)
}
コード例 #17
0
ファイル: dish.go プロジェクト: tgrosinger/mac-and-cheese
// CreateVenueDishHandler creates a new dish based on the request body
func CreateVenueDishHandler(w util.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	var dishData Dish
	if err := json.NewDecoder(r.Body).Decode(&dishData); err != nil {
		log.Println("Unable to decode create dish data:", err.Error())
		http.Error(w, "Unable to decode JSON request body", http.StatusBadRequest)
		return
	}

	venueID, err := util.GetIntParam(r, "venue_id", 0)
	if !VenueExists(c, venueID) {
		http.Error(w, "provided venue_id does not exist", http.StatusBadRequest)
		return
	}
	dishData.VenueID = venueID

	if dishData.Name == "" {
		http.Error(w, `must provide "name" field when creating a dish`, http.StatusBadRequest)
		return
	}

	key := datastore.NewIncompleteKey(c, "Dishes", nil)
	newKey, err := datastore.Put(c, key, &dishData)
	if err != nil {
		w.WriteJSON(nil, err)
		return
	}

	dishData.ID = newKey.IntID()
	w.WriteJSON(&dishData, nil)
}
コード例 #18
0
ファイル: todo.go プロジェクト: lamproae/beegae
func (t *Todo) key(c context.Context) *datastore.Key {
	if t.Id == 0 {
		t.Created = time.Now()
		return datastore.NewIncompleteKey(c, "Todo", DefaultTodoList(c))
	}
	return datastore.NewKey(c, "Todo", "", t.Id, DefaultTodoList(c))
}
コード例 #19
0
func putTweet(req *http.Request, user *User, tweet *Tweet) error {
	ctx := appengine.NewContext(req)
	userKey := datastore.NewKey(ctx, "Users", user.UserName, 0, nil)
	key := datastore.NewIncompleteKey(ctx, "Tweets", userKey)
	_, err := datastore.Put(ctx, key, tweet)
	return err
}
コード例 #20
0
ファイル: migration.go プロジェクト: trythings/trythings
func (s *MigrationService) run(ctx context.Context, m *Migration) error {
	if m.RunAt.IsZero() {
		m.RunAt = time.Now()
	}

	if m.Version.IsZero() {
		return errors.New("cannot run migration without version")
	}

	// TODO: Pipe rootKey through with context.
	rootKey := datastore.NewKey(ctx, "Root", "root", 0, nil)
	k := datastore.NewIncompleteKey(ctx, "Migration", rootKey)

	err := m.Run(ctx, s)
	if err != nil {
		return err
	}

	_, err = datastore.Put(ctx, k, m)
	if err != nil {
		return err
	}

	return nil
}
コード例 #21
0
ファイル: usage_test.go プロジェクト: favclip/qbg
func TestBasicUsage2(t *testing.T) {
	c, closer, err := aetest.NewContext()
	if err != nil {
		t.Fatal(err)
	}
	defer closer()

	src := &a.Sample{"Foo!"}
	key := datastore.NewIncompleteKey(c, "Sample", nil)
	_, err = datastore.Put(c, key, src)
	if err != nil {
		t.Fatal(err)
	}

	builder := a.NewSampleQueryBuilder()
	builder.Foo.GreaterThan("Foo").KeysOnly().Limit(3)
	iter := builder.Query().Run(c)
	for {
		key, err = iter.Next(nil)
		if err == datastore.Done {
			break
		} else if err != nil {
			t.Fatal(err)
		}
		src := &a.Sample{}
		err = datastore.Get(c, key, src)
		if err != nil {
			t.Fatal(err)
		}

		t.Logf("key: %#v, entity: %#v", key, src)
	}
}
コード例 #22
0
ファイル: challenge_impl.go プロジェクト: pbochis/api
// Put will put this Challenge into Datastore using the given key.
func (ƨ Challenge) Put(ctx context.Context, key *datastore.Key) (*datastore.Key, error) {
	if key != nil {
		return datastore.Put(ctx, key, &ƨ)
	}

	return datastore.Put(ctx, datastore.NewIncompleteKey(ctx, "Challenge", nil), &ƨ)
}
コード例 #23
0
ファイル: button.go プロジェクト: GeertJohan/timrpeterson-lab
func buttonClickedPage(w http.ResponseWriter, r *http.Request) {
	click := &clickData{
		IPAddress: r.RemoteAddr,
	}

	c := appengine.NewContext(r)
	key := datastore.NewIncompleteKey(c, "Click", clickKey(c))
	_, err := datastore.Put(c, key, click)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	clickCount, err := datastore.NewQuery("Click").Count(c)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	stats := &buttonStats{
		Clicks: clickCount,
	}

	w.Header().Set("Content-Type", "application/json")
	w.Header().Set("Cache-Control", "no-cache")
	err = json.NewEncoder(w).Encode(stats)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}
コード例 #24
0
ファイル: words.go プロジェクト: RaviTezu/GolangTraining
func handleIndex(res http.ResponseWriter, req *http.Request) {
	if req.Method == "POST" {
		term := req.FormValue("term")
		definition := req.FormValue("definition")

		ctx := appengine.NewContext(req)
		key := datastore.NewIncompleteKey(ctx, "Word", nil)

		entity := Word{
			Term:       term,
			Definition: definition,
		}

		_, err := datastore.Put(ctx, key, &entity)
		if err != nil {
			http.Error(res, err.Error(), 500)
			return
		}
	}
	res.Header().Set("Content-Type", "text/html")
	fmt.Fprintln(res, `
			<form method="POST" action="/words/">
				<input type="text" name="term">
				<textarea name="definition"></textarea>
				<input type="submit">
			</form>`)
}
コード例 #25
0
ファイル: expo.go プロジェクト: dherbst/lmjrfll
// Write the expo to the datastore, returns the key or an error
func SaveExpo(c context.Context, expo *Expo) (*datastore.Key, error) {
	key, err := datastore.Put(c, datastore.NewIncompleteKey(c, "expo", nil), expo)
	if err != nil {
		return nil, err
	}
	return key, nil
}
コード例 #26
0
ファイル: api.go プロジェクト: RobertoSuarez/GolangTraining
func tweetProcess(res http.ResponseWriter, req *http.Request, _ httprouter.Params) {
	ctx := appengine.NewContext(req)
	memItem, err := getSession(req)
	if err != nil {
		log.Infof(ctx, "Attempt to post tweet from logged out user")
		http.Error(res, "You must be logged in", http.StatusForbidden)
		return
	}
	// declare a variable of type user
	// initialize user with values from memcache item
	var user User
	json.Unmarshal(memItem.Value, &user)
	// declare a variable of type tweet
	// initialize it with values
	tweet := Tweet{
		Msg:  req.FormValue("tweet"),
		Time: time.Now(),
	}
	userKey := datastore.NewKey(ctx, "Users", user.UserName, 0, nil)
	key := datastore.NewIncompleteKey(ctx, "Tweets", userKey)
	_, err = datastore.Put(ctx, key, &tweet)
	if err != nil {
		log.Errorf(ctx, "error adding todo: %v", err)
		http.Error(res, err.Error(), 500)
		return
	}
	// redirect
	http.Redirect(res, req, "/", 302)
}
コード例 #27
0
ファイル: ListPost.go プロジェクト: jzorn/lists
func Post(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")

	ctx := appengine.NewContext(r)
	dec := json.NewDecoder(r.Body)

	var list model.List
	if err := dec.Decode(&list); err != nil {
		jsonError.NewBadRequest(err.Error()).HttpError(w)
		return
	}

	key := datastore.NewIncompleteKey(ctx, "List", nil)
	createdAt := time.Now()
	list.Id = key
	list.CreatedAt = createdAt
	list.ModifiedAt = createdAt
	list.Owner = getUser(ctx)

	for _, item := range list.Items {
		item.CreatedAt = createdAt
		item.ModifiedAt = createdAt
	}

	if _, err := datastore.Put(ctx, key, &list); err != nil {
		jsonError.NewInternalServerError(err.Error()).HttpError(w)
		return
	}

	enc := json.NewEncoder(w)
	if err := enc.Encode(list); err != nil {
		jsonError.NewInternalServerError(err.Error()).HttpError(w)
		return
	}
}
コード例 #28
0
ファイル: guestbook.go プロジェクト: kleopatra999/appengine
func handleSign(w http.ResponseWriter, r *http.Request) {
	if r.Method != "POST" {
		http.Error(w, "POST requests only", http.StatusMethodNotAllowed)
		return
	}
	c := appengine.NewContext(r)
	if err := r.ParseForm(); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	g := &Greeting{
		Content: r.FormValue("content"),
		Date:    time.Now(),
	}
	if u := user.Current(c); u != nil {
		g.Author = u.String()
	}
	key := datastore.NewIncompleteKey(c, "Greeting", guestbookKey(c))
	if _, err := datastore.Put(c, key, g); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	// Redirect with 303 which causes the subsequent request to use GET.
	http.Redirect(w, r, "/", http.StatusSeeOther)
}
コード例 #29
0
ファイル: activitylog.go プロジェクト: muly/lifelog
func ActivityLogPost(c context.Context, activityLog *ActivityLog) error {
	// generate new key
	key := datastore.NewIncompleteKey(c, "ActivityLog", nil)
	//store in database
	_, err := datastore.Put(c, key, activityLog)

	return err
}
コード例 #30
0
ファイル: data.go プロジェクト: YounessBelfqih/Golang
func makeTweet(ctx context.Context, tweet *Tweet) error {
	key := datastore.NewIncompleteKey(ctx, "Tweet", nil)
	key, err := datastore.Put(ctx, key, tweet)
	if err == nil {
		tweet.ID = key.IntID()
	}
	return err
}