Example #1
0
func (db *AppEngineDB) SaveGeneralData(d *GeneralData) error {
	if d.UserID == "" {
		return errors.New("model: invalid UserID")
	}

	var (
		key *datastore.Key
		err error
	)

	if d.Key == "" {
		key = datastore.NewIncompleteKey(db.ctx, "GeneralData", nil)
	} else {
		key, err = datastore.DecodeKey(d.Key)
		if err != nil {
			return err
		}
	}

	key, err = datastore.Put(db.ctx, key, d)
	if err != nil {
		return err
	}

	d.Key = key.Encode()
	return nil
}
Example #2
0
// This will reimburse the bid's price and fee to the buyer.
func RetireBid(c appengine.Context, key *datastore.Key) error {
	f := func(c appengine.Context) error {
		now := time.Now()
		dao := NewGaeAccountingDao(c, true)
		var bid Bid
		if err := datastore.Get(c, key, bidCodec{&bid}); err != nil {
			return err
		}

		if bid.State == Matched {
			c.Infof("Not retiring matched bid %v", key)
			return nil
		}

		if err := bid.Retire(dao, key.Encode(), now); err != nil {
			return err
		}

		if _, err := datastore.Put(c, key, bidCodec{&bid}); err != nil {
			return err
		}

		return dao.Flush()
	}

	if err := datastore.RunInTransaction(c, f, &datastore.TransactionOptions{XG: true}); err != nil {
		return err
	}

	return nil
}
Example #3
0
// Generic get by function
func GetByKey(m Model, key *datastore.Key) string {
	if err := datastore.Get(c, key, m); err != nil {
		session.AddFlash("An error occured while loading: " + err.Error())
		return ""
	}
	return key.Encode()
}
Example #4
0
func ajaxEncode(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Access-Control-Allow-Origin", "*")

	c := appengine.NewContext(r)
	var err error

	kind := trimmedFormValue(r, "kind")
	stringID := trimmedFormValue(r, "stringid")
	intIDstr := trimmedFormValue(r, "intid")
	appID := trimmedFormValue(r, "appid")
	namespace := trimmedFormValue(r, "namespace")

	// Parent (optional)
	kind2 := trimmedFormValue(r, "kind2")
	stringID2 := trimmedFormValue(r, "stringid2")
	intIDstr2 := trimmedFormValue(r, "intid2")

	// Grand-parent (optional)
	kind3 := trimmedFormValue(r, "kind3")
	stringID3 := trimmedFormValue(r, "stringid3")
	intIDstr3 := trimmedFormValue(r, "intid3")

	c.Infof("Encoding %v\n", []string{
		appID, namespace,
		kind, stringID, intIDstr,
		kind2, stringID2, intIDstr2,
		kind3, stringID3, intIDstr3,
	})

	var key, parent, grandparent *datastore.Key

	if kind2 != "" {
		if kind3 != "" {
			grandparent, err = CreateKey(c, appID, namespace, kind3, stringID3, intID64(intIDstr3), nil)
			if err != nil {
				http.Error(w, err.Error(), http.StatusBadRequest)
				return
			}
		}
		parent, err = CreateKey(c, appID, namespace, kind2, stringID2, intID64(intIDstr2), grandparent)
		if err != nil {
			http.Error(w, err.Error(), http.StatusBadRequest)
			return
		}
	}

	key, err = CreateKey(c, appID, namespace, kind, stringID, intID64(intIDstr), parent)
	if err != nil {
		c.Errorf("Failed: %v\n", err.Error())
		http.Error(w, err.Error(), http.StatusBadRequest)
		return
	}
	//fmt.Fprint(w, keyString)
	w.Header().Set("Content-Type", "application/json")
	keyString := key.Encode()
	fmt.Fprint(w, Response{
		"keystring": keyString,
	})
	c.Infof("Encoded %v\n", keyString)
}
Example #5
0
func SetSess(w http.ResponseWriter, c appengine.Context, key *datastore.Key, email string, name string) (string, *datastore.Key, error) {
	now := time.Now().Add(time.Duration(GMTADJ) * time.Second)
	h := md5.New()
	io.WriteString(h, key.Encode())
	io.WriteString(h, fmt.Sprintf("%s", now))
	md5 := fmt.Sprintf("%x", h.Sum(nil))
	ex := now.AddDate(0, 0, Expiracion)
	s := Sess{
		Md5:        md5,
		Id:         key.Encode(),
		User:       email,
		Name:       name,
		Expiration: ex,
	}
	cKey, err := datastore.Put(c, datastore.NewKey(c, "Sess", email, 0, nil), &s)
	if err != nil {
		return "", nil, err
	}
	// Se crean 2 cookies, una con el key de sesión otra con el número random llave
	//csc := http.Cookie{ Name: "ebfmex-pub-sesscontrol-ua", Value: md5, Expires: ex, Path: "/" }
	//http.SetCookie(w, &csc)
	//csc = http.Cookie{ Name: "ebfmex-pub-sessid-ua", Value: cKey.Encode(), Expires: ex, Path: "/" }
	//http.SetCookie(w, &csc)
	//w.Header().Add("Set-Cookie", fmt.Sprintf("ebfmex-pub-sesscontrol-ua=%s; expires=%s; path=/;", md5, ex.Format("Mon Jan 2 15:04:05")))
	w.Header().Add("Set-Cookie", fmt.Sprintf("ebfmex-pub-sesscontrol-ua=%v; expires=%v; path=/;", md5, ex.Format(time.ANSIC)))
	//w.Header().Add("Set-Cookie", fmt.Sprintf("ebfmex-pub-sessid-ua=%s; expires=%s; path=/;", cKey.Encode(), ex.Format("Mon Jan 2 15:04:05")))
	w.Header().Add("Set-Cookie", fmt.Sprintf("ebfmex-pub-sessid-ua=%v; expires=%v; path=/;", cKey.Encode(), ex.Format(time.ANSIC)))
	return md5, cKey, err
}
Example #6
0
// addIndexToZip generates an index.html file for the given Overlay and adds
// it to the provided zip file.
func addIndexToZip(c appengine.Context, z *zip.Writer, oKey *datastore.Key, o *Overlay) error {
	w, err := z.Create(fmt.Sprintf("%s/index.html", oKey.Encode()))
	if err != nil {
		return err
	}
	return zipTemplate.Execute(w, o)
}
Example #7
0
func saveParagraph(w http.ResponseWriter, r *http.Request) {
	if !checkUser(w, r) {
		return
	}
	ctx := appengine.NewContext(r)
	dec := json.NewDecoder(r.Body)
	var p Paragraph
	if err := dec.Decode(&p); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	var err error
	var key *datastore.Key
	keyString := r.FormValue("key")
	if keyString != "" {
		key, err = datastore.DecodeKey(keyString)
	} else {
		key = datastore.NewIncompleteKey(ctx, "Paragraph", nil)
	}
	if err == nil {
		key, err = datastore.Put(ctx, key, &p)
	}
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	w.Header().Set("Content-type", "text/plain; charset=utf-8")
	fmt.Fprintf(w, "%s", key.Encode())
}
Example #8
0
// Transactions in phase FINISHED will cause the price to be credited on the seller's
// account, and the fee to be deducted.
// All other phases will lead to price and fee being reimbursed to the buyer.
// Returns ErrTransactionTooYoung if the transaction has not passed its timout at the
// time of the call.
// Returns ErrTransactionAlreadyRetired if the transaction has already been retired at
// the time of the call.
func RetireTransaction(c appengine.Context, key *datastore.Key) error {
	f := func(c appengine.Context) error {
		now := time.Now()
		dao := NewGaeAccountingDao(c, true)
		var tx Transaction
		if err := datastore.Get(c, key, txCodec{&tx}); err != nil {
			return err
		}

		if err := tx.Retire(dao, key.Encode(), now); err == ErrTooYoung {
			return ErrTransactionTooYoung
		} else if err == ErrAlreadyRetired {
			return ErrTransactionAlreadyRetired
		} else if err != nil {
			return err
		}

		if _, err := datastore.Put(c, key, txCodec{&tx}); err != nil {
			return err
		}

		return dao.Flush()
	}

	return datastore.RunInTransaction(c, f, &datastore.TransactionOptions{XG: true})
}
Example #9
0
func redirectToBid(bidKey *datastore.Key, w http.ResponseWriter, r *http.Request) {
	bidUrl, _ := url.Parse("/bid/" + bidKey.Encode())
	bidUrl = r.URL.ResolveReference(bidUrl)
	w.Header().Set("Location", bidUrl.RequestURI())
	w.Header().Set("X-Bid-Key", bidKey.Encode())
	w.WriteHeader(http.StatusSeeOther)
}
Example #10
0
// clear the pairing cache for the specified dish/pair that is changed
func clearPairingCache(c *context, dishKey *datastore.Key, pairingKey *datastore.Key) {
	url := c.lid.Encode() + "/dish/" + dishKey.Encode() + "/pairing/"
	memcache.Delete(c.c, url)
	if pairingKey != nil {
		url += pairingKey.Encode()
		memcache.Delete(c.c, url)
	}
}
Example #11
0
func indexOfKey(keys []*datastore.Key, key *datastore.Key) int {
	for i := range keys {
		if keys[i].Encode() == key.Encode() {
			return i
		}
	}
	return -1
}
Example #12
0
func couchit(c appengine.Context, k *datastore.Key, v url.Values) error {
	vals := url.Values{
		"key": []string{k.Encode()},
	}
	for k, v := range v {
		vals[k] = v
	}
	_, err := taskqueue.Add(c, taskqueue.NewPOSTTask("/couchit", vals),
		"couchit")
	return err
}
Example #13
0
// break up the text into words and add/remove keywords  for the dish
func updateDishKeywords(c *context, key *datastore.Key, dish *Dish) {
	words := make(map[string]bool)
	addWords(dish.Name, words)
	addWords(dish.Source, words)
	addWords(dish.Text, words)
	addTags(c.c, key, words)
	if updateKeywords(c.c, key, words) {
		// if we made changes, we need to clear the cache
		cacheKey := c.lid.Encode() + "/dish/" + key.Encode() + "/keywords/"
		memcache.Delete(c.c, cacheKey)
	}
}
Example #14
0
// default data handler for "GET" to fetch one item
// returns the fetched item
func (self *dataHandler) get(key *datastore.Key) Ided {
	// create the object
	object := self.factory()
	// fetch it from the data sstore
	err := datastore.Get(self.c, key, object)
	check(err)
	// ensure the item has the proper Id in the JSON to the client
	object.SetID(key.Encode())
	// send the object to the client and cache it
	self.sendJSON(object)
	return object
}
Example #15
0
/*
	Método para borrar todas las palabras de SearchData
*/
func DelOfertaSearchData(c appengine.Context, key *datastore.Key) error {
	q := datastore.NewQuery("SearchData").Filter("Sid =", key.Encode()).KeysOnly()
	n, _ := q.Count(c)
	sd := make([]*datastore.Key, 0, n)
	if _, err := q.GetAll(c, &sd); err != nil {
		return nil
	}
	if err := datastore.DeleteMulti(c, sd); err != nil {
		return err
	}
	return nil
}
Example #16
0
// update the ingredient's keywords
func updateIngredientKeywords(c *context, key *datastore.Key,
	ing *Ingredient) {
	words := make(map[string]bool)
	addWords(ing.Name, words)
	addWords(ing.Category, words)
	addTags(c.c, key, words)
	if updateKeywords(c.c, key, words) {
		// if we made changes, we need to clear the cache
		cacheKey := c.lid.Encode() + "/ingredient/" + key.Encode() + "/keywords/"
		memcache.Delete(c.c, cacheKey)
	}
}
Example #17
0
// default data handler for "PUT" to update one item
// returns the updated item
func (self *dataHandler) update(key *datastore.Key) Ided {
	// create object to receive data
	object := self.factory()
	// read the JSON
	readJSON(self.r, object)
	// don't let user change the ID
	object.SetID(key.Encode())
	// save to the datastore
	_, err := datastore.Put(self.c, key, object)
	check(err)
	// send JSON back to the client and cache it
	self.sendJSON(object)
	return object
}
Example #18
0
// default data handler for "DELETE" to remove one itme
func (self *dataHandler) delete(key *datastore.Key) {
	// delete the item
	err := datastore.Delete(self.c, key)
	check(err)
	// remove this item from the cache
	cacheKey := self.lid.Encode() + self.r.URL.Path
	memcache.Delete(self.c, cacheKey)
	// remove the parent from the cache too
	// strip off the key from the URL
	parentURL := cacheKey[:len(cacheKey)-len(key.Encode())]
	memcache.Delete(self.c, parentURL)
	// also without the /
	memcache.Delete(self.c, parentURL[:len(parentURL)-1])
}
Example #19
0
func updateUnique(c appengine.Context, k *datastore.Key, uuid string) error {
	vals := url.Values{
		"key": []string{k.Encode()},
	}
	header := http.Header{
		"Content-Type": []string{"application/x-www-form-urlencoded"},
		uuidHeader:     []string{uuid},
	}
	_, err := taskqueue.Add(c, &taskqueue.Task{
		Path:    "/updateUnique",
		Payload: []byte(vals.Encode()),
		Header:  header,
	}, "updateunique")
	return err
}
Example #20
0
// get a permision item for the specified library
// checks memcache before datastore
func getLibPerm(c appengine.Context, uid string, libKey *datastore.Key) *Perm {
	accessCacheKey := uid + "Perm" + libKey.Encode()
	perm := &Perm{}
	_, err := memcache.Gob.Get(c, accessCacheKey, perm)
	if err != nil {
		query := datastore.NewQuery("Perm").Ancestor(libKey).Filter("UserId =", uid).Limit(1)
		iter := query.Run(c)
		if _, err = iter.Next(perm); err == nil {
			// save the permision back to the cache
			memcache.Gob.Set(c, &memcache.Item{Key: accessCacheKey, Object: perm})
		} else {
			return nil
		}
	}
	return perm
}
Example #21
0
func (db FlightDB) KeyToFlight(key *datastore.Key) (*f.Flight, error) {
	ff := f.FrozenFlight{}
	if err := datastore.Get(db.C, key, &ff); err != nil {
		return nil, err
	}

	flight, err := ff.Thaw()
	if err != nil {
		return nil, err
	}

	flight.EnterUTC, flight.LeaveUTC = flight.Track.TimesInBox(sfo.KBoxSnarfingCatchment)
	flight.SetDatastoreKey(key.Encode())

	return flight, nil
}
Example #22
0
// Transactional function to enqueue a bid, while keeping accounts in balance
func EnqueueBid(c appengine.Context, bid *Bid) (*datastore.Key, error) {
	var bidKey *datastore.Key
	f := func(c appengine.Context) error {
		dao := NewGaeAccountingDao(c, true)

		if err := bid.CheckBalance(dao); err != nil {
			return err
		}

		//parentKey := ArticleKey(c, bid.Article)
		//parentKey := AccountKey(c, bid.Participant)
		if key, err := datastore.Put(c, datastore.NewIncompleteKey(c, "Bid", nil), bidCodec{bid}); err != nil {
			return err
		} else {
			bidKey = key
		}

		if err := bid.Book(dao, bidKey.Encode()); err != nil {
			return err
		}

		if err := addRetireBidTask(c, bidKey.Encode(), bid); err != nil {
			return err
		}

		// Encode the new bid as a hotBid and put it into a pull queue
		hot := newHotBid(bidKey, bid)
		if bytes, err := json.Marshal(*hot); err != nil {
			return err
		} else {
			var task taskqueue.Task
			task.Method = "PULL"
			task.Payload = bytes
			task.Tag = string(bid.Article)
			taskqueue.Add(c, &task, "hotbids")
		}

		return dao.Flush()
	}

	if err := datastore.RunInTransaction(c, f, &datastore.TransactionOptions{XG: true}); err != nil {
		return nil, err
	}

	return bidKey, nil
}
Example #23
0
func postStats(c appengine.Context, k *datastore.Key) error {
	st := Stats{}
	err := datastore.Get(c, k, &st)
	if err != nil {
		c.Infof("Failed to load %v: %v, trying alt data", k, err)
		err = loadOldStyle(c, k, &st)
		if err != nil {
			return err
		}
	}

	if st.Data == nil || len(st.Data) < 2 {
		c.Infof("No content found, ignoring %v.", k.Encode())
		return nil
	}

	if err := st.uncompress(); err != nil {
		c.Infof("Decompression of stat data failed: %v, left %s (skipping)",
			err, st.Data)
		return nil
	}

	doc := map[string]interface{}{}
	err = json.Unmarshal(st.Data, &doc)
	if err != nil {
		c.Infof("Problem parsing stat data from %v (%v): %v - ignoring",
			k, k.Encode(), err)
		return nil
	}
	doc["timestamp"] = st.Timestamp
	doc["type"] = "stats"
	doc["active_version"] = true
	doc["api_ver"] = st.ApiVer
	doc["addr"] = st.Addr
	doc["geo"] = map[string]interface{}{
		"countryCode": st.Country,
		"cityName":    st.City,
		"regionName":  st.Region,
		"latitude":    st.Lat,
		"longitude":   st.Lon,
	}

	_, err = storeInCouch(c, doc, fmt.Sprintf("stats_%d", k.IntID()))
	return err
}
Example #24
0
func PutInvestment(c appengine.Context, i *Investment) error {
	var k *datastore.Key
	if i.Key == "" {
		k = datastore.NewIncompleteKey(c, investmentEntityName, investmentKey(c))
	} else {
		decoded, err := datastore.DecodeKey(i.Key)
		if err != nil {
			return err
		}
		k = decoded
	}
	k, err := datastore.Put(c, k, i)
	if err != nil {
		return err
	}
	i.Key = k.Encode()
	return err
}
Example #25
0
// checkDone tests whether we have generated all the tiles.
// If so, it creates a zip task on the zipper backend.
func checkDone(c appengine.Context, oKey *datastore.Key) (done bool, err error) {
	// Create a zip task if we're done and one hasn't been created already.
	tx := func(c appengine.Context) error {
		o := new(Overlay)
		err := datastore.Get(c, oKey, o)
		if err != nil {
			return err
		}

		// Check whether we have generated all the tiles.
		count, err := datastore.NewQuery("Tile").Ancestor(oKey).Count(c)
		if err != nil {
			return err
		}
		done = o.Tiles >= count
		if !done || o.Zip != "" {
			return nil
		}

		// Create a task to build the zip file,
		// targeting the zipper backend.
		task := taskqueue.NewPOSTTask("/zip", url.Values{
			"key": {oKey.Encode()},
		})
		if !appengine.IsDevAppServer() {
			host := appengine.BackendHostname(c, zipBackend, -1)
			task.Header.Set("Host", host)
		}
		if _, err := taskqueue.Add(c, task, zipQueue); err != nil {
			return err
		}

		// Store a sentinel value in Zip field to prevent a
		// second zip task from being created.
		// This value will be overwritten by the zip task.
		o.Zip = zipSentinel
		_, err = datastore.Put(c, oKey, o)
		return err
	}
	if err := datastore.RunInTransaction(c, tx, nil); err != nil {
		return false, err
	}
	return done, nil
}
Example #26
0
func loginPost(w http.ResponseWriter, r *http.Request) {
	responseType, client, err := params(r)
	if err != nil {
		err.WriteTo(w)
		return
	}
	email, password := r.FormValue("email"), r.FormValue("password")

	emailHash := model.UserEmail(email)
	context := appengine.NewContext(r)
	query := datastore.NewQuery("User").Filter("EmailHash =", emailHash)
	found, hasEntries := false, false
	var foundKey *datastore.Key
	for row := query.KeysOnly().Run(context); ; {
		key, e := row.Next(nil)
		if e == datastore.Done {
			break
		}
		query := datastore.NewQuery("Authentication").Filter("Type =", "password").Filter("User ="******"/oauth2/auth?response_type="+url.QueryEscape(responseType)+"&client_id="+
				url.QueryEscape(client.Id)+"&msgs="+url.QueryEscape("Incorrect Email or Password"), 303).ServeHTTP(w, r)
		}
	}
	if !hasEntries {
		http.RedirectHandler("/oauth2/auth?response_type="+url.QueryEscape(responseType)+"&client_id="+
			url.QueryEscape(client.Id)+"&msgs="+url.QueryEscape("Incorrect Email or Password"), 303).ServeHTTP(w, r)
	}
}
Example #27
0
func Login(rw http.ResponseWriter, req *http.Request, sess sessions.Session) {
	username := req.FormValue("username")
	password := req.FormValue("pass")

	c := appengine.NewContext(req)
	q := datastore.NewQuery("User")

	var key *datastore.Key
	for t := q.Run(c); ; {
		var u User
		k, err := t.Next(&u)
		c.Debugf("username: %s", u.Username)
		c.Debugf("password: %s", u.Password)
		if err != nil || k == nil {
			http.Redirect(rw, req, "/admin/auth?error=Failed to login", http.StatusFound)
			return
		}

		if !strings.EqualFold(username, u.Username) {
			http.Redirect(rw, req, "/admin/auth?error=Failed to login", http.StatusFound)
			return
		}

		if !strings.EqualFold(password, u.Password) {
			http.Redirect(rw, req, "/admin/auth?error=Failed to login", http.StatusFound)
			return
		}
		key = k
		break
	}

	if key == nil {
		http.Redirect(rw, req, "/admin/auth?error=Failed to login", http.StatusFound)
		return
	}

	sess.Set("auth", key.Encode())

	http.Redirect(rw, req, "/admin", http.StatusFound)
	return
}
Example #28
0
// addTilesToZip fetches all the Tile records for a given Overlay, fetches
// their associated image blobs, and adds them to the provided zip file.
func addTilesToZip(c appengine.Context, z *zip.Writer, oKey *datastore.Key) error {
	base := oKey.Encode()
	q := datastore.NewQuery("Tile").Ancestor(oKey)
	for i := q.Run(c); ; {
		var t Tile
		if _, err := i.Next(&t); err == datastore.Done {
			break
		} else if err != nil {
			return err
		}
		name := fmt.Sprintf("%s/%d/%d/%d.png", base, t.Zoom, t.X, t.Y)
		w, err := z.Create(name)
		if err != nil {
			return err
		}
		if _, err = w.Write(t.Image); err != nil {
			return err
		}
	}
	return nil
}
Example #29
0
// Create and show gamelist page
func Gamelist(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	gamekey := r.FormValue("gamekey")

	if gamekey != "" {
		c.Debugf(gamekey)
		Matching(w, r, gamekey, 2)
	} else {
		// get all games from datastore
		q := datastore.NewQuery("Game")
		games := q.Run(c)
		gameNum, _ := q.Count(c)

		// Create <li> of any games
		liTemplate :=
			`
			<li>
				<a href="/gamelist?gamekey=%s" data-transition="slide">
					<div>%s</div>
					<div>ルール:%s</div>
					<div>カードセット:%s</div>
					<div>人数:2/4</div>
				</a>
			</li>
			`
		game := new(Game)
		material := make(map[string]string)
		cardset := new(Cardset)
		rule := new(Rule)
		var gamekey *datastore.Key
		for i := 0; i < gameNum; i++ {
			gamekey, _ = games.Next(game)
			datastore.Get(c, game.Cardset, cardset)
			datastore.Get(c, game.Rule, rule)
			material["GameList"] += fmt.Sprintf(liTemplate, gamekey.Encode(), game.Name, rule.Name, cardset.Name)
		}
		Output(w, "page/game/gamelist.html", material)
	}

}
Example #30
0
func (self *DSHelpper) Entity2Model(key *datastore.Key, entity interface{}) (model interface{}) {
	// get entity type, name, value
	entityValue := reflect.ValueOf(entity).Elem()
	entityType := entityValue.Type()
	entityName := entityType.String()
	arr := strings.Split(entityName, ".")
	entityName = arr[len(arr)-1]

	// set model name, type, value
	modelName := entityName[0 : len(entityName)-6]
	// trimright has bug
	// modelName := strings.TrimRight(entityName, "Entity")
	modelType := self.structMap[modelName]
	modelValue := reflect.New(modelType).Elem()

	// copy field
	count := entityValue.NumField()
	for i := 0; i < count; i++ {
		field := entityType.Field(i)
		fieldType := field.Type
		fieldValue := entityValue.Field(i)
		modelField := modelValue.FieldByName(field.Name)
		modelFieldType := modelField.Type()

		// []byte 2 string situation
		if fieldType == self.structMap["ByteArray"] && modelFieldType == self.structMap["String"] {
			bytes := fieldValue.Interface().([]byte)
			str := string(bytes)
			fieldValue = reflect.ValueOf(str)
		}
		modelField.Set(fieldValue)
	}
	modelIDField := modelValue.FieldByName("ID")
	idValue := reflect.ValueOf(key.Encode())
	modelIDField.Set(idValue)

	model = modelValue.Interface()

	return model
}