Golang user.User类代码示例

func ustring(u *user.User) string {
	if u == nil {
		return ""
	} else {
		return u.String()
	}
}

func addEntry(w http.ResponseWriter, r *http.Request, c appengine.Context, u *user.User, t EntryType) error {
	date, err := time.Parse("2006-01-02", r.FormValue("date"))
	if err != nil {
		return err
	}

	e := Entry{Date: date, User: u.String(), Type: t}
	switch t {
	case Payment:
		amount, err := ParseCents(r.FormValue("amount"))
		if err != nil {
			return err
		}
		e.Amount = amount
		if len(r.FormValue("IsLoan")) != 0 {
			e.Type = Loan
		}
	case RateChange:
		rate, err := strconv.ParseFloat(r.FormValue("rate"), 32)
		if err != nil {
			return err
		}
		e.Rate = float32(rate)
	}

	log.Println("entry", e)
	if _, err := datastore.Put(c, datastore.NewIncompleteKey(c, "Entry", nil), &e); err != nil {
		return err
	}
	http.Redirect(w, r, "/", http.StatusFound)
	return nil
}

func InvalidUserPage(c appengine.Context, w http.ResponseWriter, r *http.Request, u *user.User) {
	w.Header().Set("Content-Type", "text/html")
	w.WriteHeader(http.StatusForbidden)

	logoutUrl, err := LogoutURL(c, r)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	if err := notAllowedTemplate.Execute(w, notAllowedParams{u.String(), logoutUrl}); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}
}

func articleGo(context appengine.Context, user *user.User, request *http.Request) (data Data, err error) {
	id := request.FormValue("id")
	if id != "" {
		var userkey *datastore.Key
		var userdata UserData
		userkey, userdata, err = mustGetUserData(context, user.String())
		if err != nil {
			return
		}

		article := getArticleById(userdata.Articles, id)
		userdata, err = selected(context, userdata, article)
		if err != nil {
			return
		}

		_, err = putUserData(context, userkey, userdata)
		if err != nil {
			return
		}
	}

	url := request.FormValue("url")
	if url != "" {
		return Redirect{URL: url}, nil
	}

	return
}

func feedPOST(context appengine.Context, user *user.User, request *http.Request) (data Data, err error) {
	var userdata UserData
	var userkey *datastore.Key
	userkey, userdata, err = mustGetUserData(context, user.String())
	if err != nil {
		return
	}

	if request.FormValue("clear") != "" {
		err = unsubscribeAll(context, &userdata)
	}

	if request.FormValue("input") == "json" {
		err = feedJSONPOST(context, &userdata, request)
	} else if request.FormValue("input") == "opml" {
		err = feedOPMLPOST(context, &userdata, request)
	} else if request.FormValue("input") == "form" || request.FormValue("url") != "" {
		err = subscribe(context, &userdata, request.FormValue("url"), false)
	}
	if err != nil {
		return
	}

	_, err = putUserData(context, userkey, userdata)
	if err != nil {
		return
	}

	redirect := Redirect{URL: "/app"}
	return redirect, nil
}

func feedDELETE(context appengine.Context, user *user.User, request *http.Request) (data Data, err error) {
	var userdata UserData
	var userkey *datastore.Key
	userkey, userdata, err = mustGetUserData(context, user.String())
	if err != nil {
		return
	}

	if request.FormValue("url") != "" {
		err = unsubscribe(context, &userdata, request.FormValue("url"))
	} else {
		err = unsubscribeAll(context, &userdata)
	}
	if err != nil {
		return
	}

	_, err = putUserData(context, userkey, userdata)
	if err != nil {
		return
	}

	redirect := Redirect{URL: "/app"}
	return redirect, nil
}

func CreateUserAppengine(c appengine.Context, appengineUser *user.User) (*User, error) {
	u := &User{
		Key: UserKey(c, appengineUser.ID),

		Name:       appengineUser.String(),
		Email:      appengineUser.Email,
		AuthDomain: appengineUser.AuthDomain,
		IsAdmin:    user.IsAdmin(c),

		FederatedIdentity: appengineUser.FederatedIdentity,
		FederatedProvider: appengineUser.FederatedProvider,
	}
	if err := SaveUser(c, u); err != nil {
		c.Errorf("SaveUser error: " + err.Error())
	}
	return u, nil
}

func CreateUserFromAppengine(c appengine.Context, appengineUser *user.User) (*User, error) {
	u := &User{
		UserId: appengineUser.ID,

		Name:       appengineUser.String(),
		Email:      appengineUser.Email,
		AuthDomain: appengineUser.AuthDomain,
		IsAdmin:    user.IsAdmin(c),

		FederatedIdentity: appengineUser.FederatedIdentity,
		FederatedProvider: appengineUser.FederatedProvider,
	}
	initUser(u)
	if err := entity.Put(c, u); err != nil {
		return nil, err
	}
	return u, nil
}

func save_user(w http.ResponseWriter, c appengine.Context, u *user.User) {
	el := Record{
		GroupId:    "11",
		Name:       u.String(),
		ID:         u.ID,
		Email:      u.Email,
		AuthDomain: u.AuthDomain,
		ReceivedAt: time.Now(),
	}
	_, err := datastore.Put(
		c,
		datastore.NewIncompleteKey(c, "records", nil),
		&el,
	)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

func feedGET(context appengine.Context, user *user.User, request *http.Request) (data Data, err error) {
	u := request.FormValue("url")
	if u != "" {
		return feedURLGET(context, u)
	}

	feedData := FeedData{User: user.String()}

	var userdata UserData
	_, userdata, err = mustGetUserData(context, user.String())
	if err != nil {
		return
	}

	for _, feed := range userdata.Feeds {
		var item Feed
		for _, defaultFeed := range builtinFeeds {
			if defaultFeed.URL == feed {
				item = defaultFeed
				break
			}
		}

		if item.URL == "" {
			_, err = GetFirst(context, "Feed", "URL", feed, &item)
			if err != nil {
				printError(context, err, feed)
				err = nil
				continue
			}
		}

		feedData.Feeds = append(feedData.Feeds, item)
	}

	feedData.SuggestedFeeds, err = getSuggestedFeeds(context, userdata)
	if err != nil {
		return
	}

	return feedData, nil
}

// API to insert a new door. Requires "displayName", "regId" and "devId" of the
// device. Only admins can execute this API at the moment.
func insertDoor(
	r *http.Request, c appengine.Context, u *user.User) (*[]ApiDoor, error) {
	displayName := r.FormValue("displayName")
	if displayName == "" {
		return nil, Err{"'displayName' required.", http.StatusBadRequest}
	}
	regId := r.FormValue("regId")
	if regId == "" {
		return nil, Err{"'regId' required.", http.StatusBadRequest}
	}
	devId := r.FormValue("devId")
	if devId == "" {
		return nil, Err{"'devId' required.", http.StatusBadRequest}
	}
	if !u.Admin {
		return nil, Err{"You are not an admin.", http.StatusForbidden}
	}

	// TODO(robert): Wrap these in a txn.

	uKey := ds.NewKey(c, "User", u.ID, 0, nil)
	if err := getOrCreateUser(c, uKey, &User{u.String()}); err != nil {
		return nil, err
	}

	d := Door{displayName, regId, devId}
	dKey, err := ds.Put(c, ds.NewIncompleteKey(c, "Door", nil), &d)
	if err != nil {
		return nil, err
	}

	if _, err = ds.Put(c, ds.NewIncompleteKey(c, "Permission", nil),
		&Permission{uKey, dKey, LevelOwner}); err != nil {
		c.Errorf(
			"Created door (%s) but owner permission creation failed.", dKey.Encode())
		return nil, err
	}

	return &[]ApiDoor{ApiDoor{dKey.Encode(), d.DisplayName, d.RegId, d.DevId}},
		nil
}

// fetch the user's own library (not necessarily their current library)
// checks memcache first, then datastore.  Populates the cache
// returns the key, library and a boolean that is true if the library is new
func getOwnLibrary(c appengine.Context, u *user.User) (*datastore.Key, *Library, bool) {
	uid := u.ID
	if len(uid) == 0 {
		uid = u.Email
	}
	init := false
	lid := datastore.NewKey(c, "Library", uid, 0, nil)
	l := &Library{}
	_, err := memcache.Gob.Get(c, lid.Encode(), l)
	if err == memcache.ErrCacheMiss {
		err = datastore.Get(c, lid, l)
		if err == datastore.ErrNoSuchEntity {
			l = &Library{uid, 0, u.String(), ""}
			lid, err = datastore.Put(c, lid, l)
			check(err)
			init = true
		}
		memcache.Gob.Set(c, &memcache.Item{Key: lid.Encode(), Object: l})
	}
	return lid, l, init
}

// Message_page presents a simple message page and presents the user
// with a link that leads to a followup page.
func Message_page(w http.ResponseWriter,
	r *http.Request,
	login_user *user.User,
	msg string,
	return_msg string,
	return_url string) {

	c := appengine.NewContext(r)
	tmpl, err := template.ParseFiles("header.html",
		"message.html")
	if err != nil {
		ServeError(&c, w, err)
		return
	}

	type TV struct {
		User      string
		LoggedIn  bool
		Msg       string
		ReturnUrl string
		ReturnMsg string
		LogoutUrl string
	}

	template_values := new(TV)
	if login_user != nil {
		template_values.User = login_user.String()
	} else {
		template_values.User = ""
	}
	template_values.LoggedIn = login_user != nil
	template_values.Msg = msg
	template_values.ReturnUrl = return_url
	template_values.ReturnMsg = return_msg

	if err := tmpl.ExecuteTemplate(w, "message.html",
		template_values); err != nil {
		c.Errorf("Failed to execute template: %v", err)
	}
}

func insertPermission(
	r *http.Request, c appengine.Context, u *user.User) (*[]Permission, error) {
	dKey, err := ds.DecodeKey(r.FormValue("doorKey"))
	if err != nil {
		return nil, ErrNoDoorKey
	}

	uKey := ds.NewKey(c, "User", u.ID, 0, nil)
	cnt := 0
	cnt, err = ds.NewQuery("Permission").
		Filter("userKey=", uKey).
		Filter("doorKey=", dKey).
		Count(c)
	if err != nil {
		return nil, err
	}
	if cnt > 0 {
		return nil, ErrApplyReject
	}

	if err = ds.Get(c, dKey, &Door{}); err != nil {
		if err == ds.ErrNoSuchEntity {
			err = ErrApplyReject
		}
		return nil, err
	}

	// Create user if doesn't already exist.
	if err := getOrCreateUser(c, uKey, &User{u.String()}); err != nil {
		return nil, err
	}

	// Create pending permission to door.
	p := Permission{uKey, dKey, LevelPending}
	if _, err = ds.Put(c, ds.NewIncompleteKey(c, "Permission", nil), &p); err != nil {
		return nil, err
	}

	return &[]Permission{p}, nil
}

func deleter(w http.ResponseWriter, r *http.Request, c appengine.Context, u *user.User) error {
	keyID := r.FormValue("KeyID")
	log.Print("deleter", keyID)
	if keyID == "" {
		return fmt.Errorf("attempt to delete with null key")
	}
	key, err := datastore.DecodeKey(keyID)
	log.Print("err", err, "key", key)
	if err != nil {
		return err
	}
	var e Entry
	if err = datastore.Get(c, key, &e); err != nil {
		return err
	}
	e.Deleted = true
	e.DeleteUser = u.String()
	if _, err = datastore.Put(c, key, &e); err != nil {
		return err
	}
	log.Print("redirecting")
	http.Redirect(w, r, "/", http.StatusFound)
	return nil
}