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

func ServiceHandlers_ChatGetMessages(request *restful.Request, response *restful.Response) {

	// Input
	//UserId := request.PathParameter("UserId")
	//LastMessageId := request.PathParameter("LastMessageId")

	// Search
	context := appengine.NewContext(request.Request)
	querySize1 := 100

	query1 := datastore.NewQuery("Chat").Order("When").Limit(querySize1)
	queryResult1 := make([]Chat, 0, querySize1)
	query1.GetAll(context, &queryResult1)

	querySize2 := 5000
	query2 := datastore.NewQuery("User").Limit(querySize2)
	queryResult2 := make([]User, 0, querySize2)
	query2.GetAll(context, &queryResult2)

	m := make(map[string]string)
	for i := 0; i < len(queryResult2); i++ {
		m[queryResult2[i].Id] = queryResult2[i].Name
	}

	for j := 0; j < len(queryResult1); j++ {
		queryResult1[j].OwnerId = m[queryResult1[j].OwnerId]
		queryResult1[j].WhenAsString = queryResult1[j].When.Format("2006/01/02 03:04:05")
	}

	// Output
	bytes, _ := json.Marshal(queryResult1)
	response.Write(bytes)
}

func cleanImage(w http.ResponseWriter, r *http.Request) {
	// Con esta manejador borramos las imagenes que no están asociadas a
	// ningún punto y han quedado huerfanas

	c := appengine.NewContext(r)

	var blobs []blobstore.BlobInfo

	q := datastore.NewQuery("__BlobInfo__")
	keys, _ := q.GetAll(c, &blobs)
	for _, key := range keys {

		var imgk = appengine.BlobKey(key.StringID())

		// Busco algun punto con esa key como imagen
		var points []points.Point
		qp := datastore.NewQuery("points").Filter("ImageKey = ", imgk)
		qp.GetAll(c, &points)
		if len(points) == 0 {
			// borro la imagen
			c.Infof("borro imagen %s", imgk)
			err := blobstore.Delete(c, imgk)
			if err != nil {
				app.ServeError(c, w, err)
				return
			}
		}
	}
}

func ServiceHandlers_LoadBorrow(request *restful.Request, response *restful.Response) {

	// Input
	//UserId := request.PathParameter("UserId")

	context := appengine.NewContext(request.Request)
	querySize := 5000

	// Search 1
	query1 := datastore.NewQuery("Borrow").Limit(querySize)
	queryResult1 := make([]Borrow, 0, querySize)
	query1.GetAll(context, &queryResult1)

	// Search 2
	query2 := datastore.NewQuery("BorrowWant").Limit(querySize)
	queryResult2 := make([]BorrowWant, 0, querySize)
	query2.GetAll(context, &queryResult2)

	// Update
	m := make(map[string]int)
	for i := 0; i < len(queryResult2); i++ {
		m[queryResult2[i].ItemId] = m[queryResult2[i].ItemId] + 1
	}

	for j := 0; j < len(queryResult1); j++ {
		queryResult1[j].WantCount = m[queryResult1[j].Id]
	}

	bytes, _ := json.Marshal(queryResult1)

	response.Write(bytes)
}

func DeleteTweetsByHashtag(c appengine.Context, hashtag string) error {
	c.Debugf("DeleteTweetsByHashtag")
	q := datastore.NewQuery("Tweet").Filter("Hashtag =", hashtag).Order("Created_At").Limit(300)
	var tweets []Tweet
	keys, err := q.GetAll(c, &tweets)
	if err != nil {
		c.Errorf("DeleteTweetsByHashtag failed to get: %v", err)
		return err
	}
	c.Debugf("DeleteTweetsByHashtag keys for delete: %v", keys)
	for _, tweet := range tweets {
		c.Infof("DeleteTweetsByHashtag tweet for delete: %v", tweet.Text)
	}
	if err = datastore.DeleteMulti(c, keys); err != nil {
		c.Errorf("DeleteTweetsByHashtag failed to delete tweet: %v", err)
		return err
	}

	//tweetを削除した結果、tweetが無かったら、Hashtagを削除する
	length, err := datastore.NewQuery("Tweet").Filter("Hashtag =", hashtag).Count(c)
	if err != nil {
		c.Errorf("DeleteTweetsByHashtag failed to get count: %v", err)
		return err
	}
	c.Debugf("DeleteTweetsByHashtag tweets length: %d", length)
	if length == 0 {
		c.Infof("DeleteTweetsByHashtag delete Hashtag: %s", hashtag)
		if err := DeleteHashtag(c, hashtag); err != nil {
			c.Errorf("DeleteTweetsByHashtag failed to delete hashtag: %v", err)
			return err
		}
	}
	return nil
}

func See(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	q := datastore.NewQuery("Pay").Order("-Date").Limit(100)
	k := make([]Pay, 0, 100)
	_, err1 := q.GetAll(c, &k)
	//fmt.Fprintf(w,len(k))
	if err1 != nil {
		http.Error(w, err1.Error(), http.StatusInternalServerError)
		return
	}
	if err := SeePTemplate.Execute(w, k); err != nil {
		http.Error(w, err1.Error(), http.StatusInternalServerError)
	}
	q2 := datastore.NewQuery("Trans").Limit(100)
	l := make([]Trans, 0, 100)
	_, err2 := q2.GetAll(c, &l)
	//fmt.Fprintf(w,len(l))
	if err2 != nil {
		http.Error(w, err2.Error(), http.StatusInternalServerError)
		return
	}
	if err := SeeTTemplate.Execute(w, l); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}
}

func handleIndex(w http.ResponseWriter, r *http.Request) {
    c := appengine.NewContext(r)

    // Get user info
    userInfo := getUserInfo(c)

    // Get post id and page id
    pageId, _ := strconv.Atoi(getUrlQuery(r.URL, "pid"))
    pageSize  := config.PageSize

    // Get offset and page numbers
    offset, pageNums := getOffset("Article", pageId, pageSize, c)

    // New PageSetting
    pageSetting := new(PageSetting)

    // Setting PageSetting
    pageSetting.Title       = config.Title
    pageSetting.Description = config.Description
    pageSetting.Layout      = "column2"
    pageSetting.ShowSidebar = true

    // showNext and showPrev button
    if pageId <= 0 || pageId > pageNums {
        pageId = 1
    }
    if pageId < pageNums {
        pageSetting.ShowPrev = true
    }
    if pageId != 1 {
        pageSetting.ShowNext = true
    }
    pageSetting.PrevPageID = pageId + 1
    pageSetting.NextPageID = pageId - 1

    // Get article data
    dbQuery          := datastore.NewQuery("Article").Order("-Date").Offset(offset).Limit(pageSize)
    articleData, err := getArticleData(dbQuery, true, c)
    if err != nil {
        serveError(c, w, err)
        return
    }

    // Get widget data
    dbQuery          = datastore.NewQuery("Widget").Order("Sequence")
    widgetData, err := getWidgetData(dbQuery, true, c)
    if err != nil {
        serveError(c, w, err)
        return
    }

    // New PageData
    pageData := &PageData{ User: userInfo, Article: articleData, Widget: widgetData }

    // New Page
    page := NewPage(pageSetting, pageData)

    // Render page
    page.Render("index", w)
}

func addTagToFact(c appengine.Context, factKey *datastore.Key, tag string) {
	q := datastore.NewQuery("Tag").Filter("Name =", tag)
	cnt, _ := q.Count(c)
	var existingTag Tag
	var existingTagKey *datastore.Key
	if cnt > 0 {
		// retrieve
		for t := q.Run(c); ; {
			existingTagKey, _ = t.Next(&existingTag)
			break // only need one
		}
	} else {
		// create a new one
		var t = Tag{Name: tag}
		existingTagKey, _ = datastore.Put(c, datastore.NewIncompleteKey(c, "Tag", nil), &t)
	}
	qft := datastore.NewQuery("FactTag").
		Filter("Fact = ", factKey).
		Filter("Tag = ", existingTagKey)
	cnt2, _ := qft.Count(c)
	if cnt2 == 0 {
		// create a new one
		var ft = FactTag{Fact: factKey, Tag: existingTagKey}
		_, _ = datastore.Put(c, datastore.NewIncompleteKey(c, "FactTag", nil), &ft)
	}
}

// Get returns an User by id, name or SocialAccount.Name
func (dsum *DataStoreUserManager) Get(id string) (u *User, err error) {
	u = &User{}
	intid, err := strconv.ParseInt(id, 10, 64)
	if err == nil && intid != 0 {
		u, err = dsum.getById(intid)
		if err != datastore.ErrNoSuchEntity {
			return
		}
	}
	q := datastore.NewQuery("User").Filter("Name =", id)
	t := q.Run(dsum.c)
	_, err = t.Next(u)
	if err != datastore.Done {
		return
	}
	q = datastore.NewQuery("User").Filter("Email =", id)
	t = q.Run(dsum.c)
	_, err = t.Next(u)
	if err != datastore.Done {
		return
	}
	q = datastore.NewQuery("User").Filter("Accounts.Name =", id)
	t = q.Run(dsum.c)
	_, err = t.Next(u)
	if err != datastore.Done {
		return
	}
	return nil, datastore.ErrNoSuchEntity
}

func DeleteOldFeed(c mpg.Context, w http.ResponseWriter, r *http.Request) {
	g := goon.FromContext(c)
	oldDate := time.Now().Add(-time.Hour * 24 * 90)
	feed := Feed{Url: r.FormValue("f")}
	if err := g.Get(&feed); err != nil {
		c.Criticalf("err: %v", err)
		return
	}
	if feed.LastViewed.After(oldDate) {
		return
	}
	q := datastore.NewQuery(g.Kind(&Story{})).Ancestor(g.Key(&feed)).KeysOnly()
	keys, err := q.GetAll(c, nil)
	if err != nil {
		c.Criticalf("err: %v", err)
		return
	}
	q = datastore.NewQuery(g.Kind(&StoryContent{})).Ancestor(g.Key(&feed)).KeysOnly()
	sckeys, err := q.GetAll(c, nil)
	if err != nil {
		c.Criticalf("err: %v", err)
		return
	}
	keys = append(keys, sckeys...)
	c.Infof("delete: %v - %v", feed.Url, len(keys))
	err = g.DeleteMulti(keys)
	if err != nil {
		c.Criticalf("err: %v", err)
	}
}

// Show the front page
func RootHandler(c appengine.Context, w http.ResponseWriter, r *http.Request) {
	p := setup(c, r)

	var items []Item
	q := datastore.NewQuery("Item").Order("-Score")
	keys, err := q.GetAll(c, &items)
	check(err, "Could not load items.")

	var votes []Vote
	q = datastore.NewQuery("Vote").Filter("OwnerKey=", p.User.userKey).Filter("ParentType=", "Item")
	q.GetAll(c, &votes) // Eat the error, we don't care if we can't load votes

	var vote Vote

	for i, key := range keys {
		items[i].itemKey = key
		items[i].loadOwner(c)
		if len(votes) > 0 {
			for _, vote = range votes {
				if items[i].itemKey.IntID() == vote.ParentKey.IntID() {
					items[i].SessionUserVote = vote.Value
				}
			}
		}
	}

	p.Data["Items"] = items

	renderTemplate(w, "index.html", p)
}

func computeRank(c appengine.Context, userId int64, examId int64) ([]Rank, error) {
	score := make([]Rank, 0, 0)
	q := datastore.NewQuery("ExamResult")
	for t := q.Run(c); ; {
		var e ExamResult
		_, err := t.Next(&e)
		if err == datastore.Done {
			break
		}
		if err != nil {
			return score, err
		}
		if (userId == -1 || e.UserId == userId) && (examId == -1 || e.ExamId == examId) {
			err, s := getExamResultScore(c, e)
			if err != nil {
				return score, err
			}
			var userName, examName string
			var userProf []UserProfile
			var exam []Exam
			q := datastore.NewQuery("UserProfile").Filter("UserId =", e.UserId)
			if _, err := q.GetAll(c, &userProf); err == nil && len(userProf) > 0 {
				userName = userProf[0].FirstName + " " + userProf[0].LastName
			}
			q2 := datastore.NewQuery("Exam").Filter("Id =", e.ExamId)
			if _, err := q2.GetAll(c, &exam); err == nil && len(exam) > 0 {
				examName = exam[0].Name
			}
			score = append(score, Rank{e.ExamId, examName, e.UserId, userName, s})
		}
	}
	return score, nil
}

func Clean(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	q := datastore.NewQuery("User").Limit(100)
	x := make([]User, 0, 100)
	k, err := q.GetAll(c, &x)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	datastore.DeleteMulti(c, k)
	q2 := datastore.NewQuery("Pay").Limit(100)
	x2 := make([]Pay, 0, 100)
	k2, err2 := q2.GetAll(c, &x2)
	if err2 != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	datastore.DeleteMulti(c, k2)
	q3 := datastore.NewQuery("Trans").Limit(100)
	x3 := make([]Trans, 0, 100)
	k3, err3 := q3.GetAll(c, &x3)
	if err3 != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	datastore.DeleteMulti(c, k3)

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

func (session *Session) DatastoreInfo() (err error) {
	c, err := session.AppEngineContext()
	if err != nil {
		log.Fatalf("Failed to create context: %v", err)
		return
	}
	log.Printf("App ID %q", appengine.AppID(c))

	q := datastore.NewQuery(DatastoreKindName).Order("kind_name")
	kinds := []*DatastoreKind{}
	if _, err := q.GetAll(c, &kinds); err != nil {
		log.Fatalf("Failed to fetch kind info: %v", err)
	}

	for _, k := range kinds {
		fmt.Printf("\nkind %q\t%d entries\t%d bytes\n", k.KindName, k.Count, k.Bytes)
		if false {
			props := datastore.PropertyList{}
			if _, err := datastore.NewQuery(k.KindName).Limit(1).Run(c).Next(&props); err != nil {
				log.Printf("Unable to fetch sample entity kind %q: %v", k.KindName, err)
				continue
			}
			for _, prop := range props {
				fmt.Printf("\t%s: %v\n", prop.Name, prop.Value)
			}
		}
	}
	return
}

func AdminUser(c mpg.Context, w http.ResponseWriter, r *http.Request) {
	gn := goon.FromContext(c)
	q := datastore.NewQuery(gn.Key(&User{}).Kind()).Limit(1)
	q = q.Filter("e =", r.FormValue("u"))
	it := gn.Run(q)
	var u User
	ud := UserData{Id: "data"}
	var h []Log
	k, err := it.Next(&u)
	if err == nil {
		q = datastore.NewQuery(gn.Key(&Log{}).Kind()).Ancestor(k)
		_, err = gn.GetAll(q, &h)
		ud.Parent = gn.Key(&u)
		gn.Get(&ud)
	}
	if err := templates.ExecuteTemplate(w, "admin-user.html", struct {
		User  User
		Data  UserData
		Log   []Log
		Error error
	}{
		u,
		ud,
		h,
		err,
	}); err != nil {
		serveError(w, err)
	}
}

func (p *Puzzle) UpdatableProgressInfo(c appengine.Context, h *hunt.Hunt, t *team.Team) UpdatableProgressInfo {
	u := UpdatableProgressInfo{
		AvailablePoints: p.PointValue,
		Solved:          false,
		GrantedPoints:   0,
		SolveTimes:      nil,
		Answerable:      t != nil && !t.Key.Equal(p.Team),
	}
	if t != nil {
		var solves []Solve
		_, err := datastore.NewQuery(solveKind).Ancestor(h.Key).Filter("Puzzle =", p.Key).Filter("Team =", t.Key).Limit(1).GetAll(c, &solves)
		if err != nil {
			c.Errorf("Error: %v", err)
		}
		if len(solves) > 0 {
			u.Solved = true
			u.GrantedPoints = solves[0].Points
			u.Answerable = false
		}
	}
	var solves []Solve
	_, err := datastore.NewQuery(solveKind).Ancestor(h.Key).Filter("Puzzle =", p.Key).Order("Time").GetAll(c, &solves)
	if err != nil {
		c.Errorf("Error: %v", err)
	}
	for _, s := range solves {
		u.SolveTimes = append(u.SolveTimes, s.Time.In(h.GetTimezone(c)).Format("15:04:05"))
	}
	return u
}

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 getQuery(r *http.Request, postID int64, numToRender int, queryType string) ([]*datatypes.Post, error) {
	c := appengine.NewContext(r)
	q := datastore.NewQuery(queryType)
	if postID > -1 {
		// According to https://developers.google.com/appengine/docs/go/datastore/queries#Go_Filters,
		// Query.Filter("__key__="...) matches keys in order of
		// 1. Ancestor path
		// 2. Entity kind
		// 3 Identifier (key name or numeric ID)
		// So by making a new key with the same type and ancestor path (no ancestors) and with the same postID, the two can be matched and returned from the query.
		// There has got to be a better way to do this, and this might be a waste of a key, but since uses the same ID, maybe it doesn't matter.
		q = datastore.NewQuery(queryType).Filter("__key__=", datastore.NewKey(c, queryType, "", postID, nil)).Order("-GoDate")
	} else if numToRender != -1 {
		q = datastore.NewQuery(queryType).Order("-GoDate").Limit(numToRender)
	}

	var allPosts []*datatypes.Post
	keys, err := q.GetAll(c, &allPosts)
	if err != nil {
		return nil, err
	}

	for i := range allPosts {
		allPosts[i].ID = keys[i].IntID()
	}
	sort.Sort(sort.Reverse(datatypes.Posts(allPosts)))

	return allPosts, nil
}

/*
This call deletes and creates unit-testing data.
*/
func (h *System) CreateTestData(r *http.Request, args *SystemArgs, reply *GeneralReply) error {
	c := appengine.NewContext(r)
	var err error

	// delete any previous testing data
	{
		var keys_to_delete []*datastore.Key

		REGION_UIDS_TO_DELETE := []string{"@test-san-francisco", "@test-los-angeles"}
		RESTAURANT_UIDS_TO_DELETE := []string{"@test-mcdonalds", "@test-In-N-Out", "@test-Wendys"}
		TAGS_UIDS_TO_DELETE := []string{"@test-american", "@test-french"}

		for _, uid := range REGION_UIDS_TO_DELETE {
			q := datastore.NewQuery("Tags").Filter("Uid =", uid).KeysOnly()
			keys_to_delete, err = q.GetAll(c, nil)
			checkErr(err, "DB error1")
			err = datastore.DeleteMulti(c, keys_to_delete)
			checkErr(err, "DB error2")
		}
		for _, uid := range RESTAURANT_UIDS_TO_DELETE {
			q := datastore.NewQuery("Region").Filter("Uid =", uid).KeysOnly()
			keys_to_delete, err = q.GetAll(c, nil)
			checkErr(err, "DB error3")
			err = datastore.DeleteMulti(c, keys_to_delete)
			checkErr(err, "DB error4")
		}

		for _, uid := range TAGS_UIDS_TO_DELETE {
			q := datastore.NewQuery("Restaurant").Filter("Uid =", uid).KeysOnly()
			_, err = q.GetAll(c, &keys_to_delete)
			checkErr(err, "DB error5")
			err = datastore.DeleteMulti(c, keys_to_delete)
			checkErr(err, "DB error6")
		}
		log.Printf("... cleanup done")
	}

	// re-create the data (unless this was a cleanup operation only)
	if !args.CleanupOnly {
		region1 := models.Region{Uid: "@test-san-francisco", Title: "TEST San Francisco"}
		_, err = datastore.Put(c, datastore.NewKey(c, "Region", region1.Uid, 0, nil), &region1)
		checkErr(err, "fail trying to insert")
		region2 := models.Region{Uid: "@test-los-angeles", Title: "TEST Los Angeles"}
		_, err = datastore.Put(c, datastore.NewKey(c, "Region", region2.Uid, 0, nil), &region2)
		checkErr(err, "fail trying to insert")

		restaurant1 := models.Restaurant{Uid: "@test-mcdonalds", Title: "TEST McDonalds", Tags: []string{"French Cuisine", "American"}, Regions: []string{region1.Uid}}
		_, err = datastore.Put(c, datastore.NewKey(c, "Restaurant", restaurant1.Uid, 0, nil), &restaurant1)
		checkErr(err, "fail trying to insert")
		restaurant2 := models.Restaurant{Uid: "@test-In-N-Out", Tags: []string{"American"}, Regions: []string{region1.Uid, region2.Uid}}
		_, err = datastore.Put(c, datastore.NewKey(c, "Restaurant", restaurant2.Uid, 0, nil), &restaurant2)
		checkErr(err, "fail trying to insert")
		restaurant3 := models.Restaurant{Uid: "@test-Wendys", Tags: []string{"American"}, Regions: []string{region2.Uid}}
		_, err = datastore.Put(c, datastore.NewKey(c, "Restaurant", restaurant3.Uid, 0, nil), &restaurant3)
		checkErr(err, "fail trying to insert")

		log.Printf("... creation done")
	}
	return nil
}

func DiscoverHandler(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	vineApi := VineRequest{c}
	db := DB{c}
	var recentUsers []*VineUser
	var recentVerified []StoredUserMeta

	recent := datastore.NewQuery("Queue").Order("-Discovered").Limit(5).KeysOnly()
	k, _ := recent.GetAll(c, nil)
	for i, _ := range k {
		user, err := vineApi.GetUser(strconv.FormatInt(k[i].IntID(), 10))
		if err == nil {
			recentUsers = append(recentUsers, user)
		}
	}
	verified := datastore.NewQuery("UserMeta").Filter("Verified =", true).Limit(5).KeysOnly()
	k, _ = verified.GetAll(c, nil)
	for i, _ := range k {
		user, err := db.GetUserMeta(k[i].IntID())
		if err == nil {
			recentVerified = append(recentVerified, user.(StoredUserMeta))
		}
	}
	data := map[string]interface{}{"recentUsers": recentUsers, "recentVerified": recentVerified}
	dir := path.Join(os.Getenv("PWD"), "templates")
	discover := path.Join(dir, "discover.html")
	layout := path.Join(dir, "pageLayout.html")
	page := mustache.RenderFileInLayout(discover, layout, data)
	fmt.Fprint(w, page)
}

func watashi(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	ks, err := datastore.NewQuery("feed").KeysOnly().GetAll(c, nil)
	if err != nil {
		handleError(w, err)
		return
	}
	for _, k := range ks {
		err = subscribe(c, k, false)
		if err != nil {
			handleError(w, err)
			return
		}
	}
	ks, err = datastore.NewQuery("item").Filter("Read =", false).KeysOnly().GetAll(c, nil)
	if err != nil {
		handleError(w, err)
		return
	}
	for _, k := range ks {
		propagate.Call(c, k)
		fmt.Fprintln(w, k)
	}
	fmt.Fprintln(w, "OK!")
}