func getUserCard(g *libkb.GlobalContext, uid keybase1.UID, useSession bool) (ret *keybase1.UserCard, err error) {
defer g.Trace("getUserCard", func() error { return err })()
arg := libkb.APIArg{
Endpoint: "user/card",
NeedSession: useSession,
Contextified: libkb.NewContextified(g),
Args: libkb.HTTPArgs{"uid": libkb.S{Val: uid.String()}},
}
var card card
if err = g.API.GetDecode(arg, &card); err != nil {
g.Log.Warning("error getting user/card for %s: %s\n", uid, err)
return nil, err
}
g.Log.Debug("user card: %+v", card)
ret = &keybase1.UserCard{
Following: card.FollowSummary.Following,
Followers: card.FollowSummary.Followers,
Uid: uid,
FullName: card.Profile.FullName,
Location: card.Profile.Location,
Bio: card.Profile.Bio,
Website: card.Profile.Website,
Twitter: card.Profile.Twitter,
YouFollowThem: card.YouFollowThem,
TheyFollowYou: card.TheyFollowYou,
}
return ret, nil
}
func (m localUserMap) getLocalUser(uid keybase1.UID) (LocalUser, error) {
user, ok := m[uid]
if !ok {
return LocalUser{}, NoSuchUserError{uid.String()}
}
return user, nil
}
// NewRekeyPermissionError constructs a RekeyPermissionError for the given
// directory and user.
func NewRekeyPermissionError(ctx context.Context, config Config, dir *TlfHandle,
uid keybase1.UID) error {
dirname := dir.ToString(ctx, config)
if name, err2 := config.KBPKI().GetNormalizedUsername(ctx, uid); err2 == nil {
return RekeyPermissionError{string(name), dirname}
}
return RekeyPermissionError{uid.String(), dirname}
}
func NewUserConfig(id keybase1.UID, name NormalizedUsername, salt []byte, dev keybase1.DeviceID) *UserConfig {
ret := &UserConfig{
ID: id.String(),
Name: name,
Salt: hex.EncodeToString(salt),
Device: nil,
importedID: id,
importedSalt: salt,
importedDeviceID: dev,
}
if dev.Exists() {
tmp := dev.String()
ret.Device = &tmp
}
return ret
}
func (u *userKeyAPI) GetUser(ctx context.Context, uid keybase1.UID) (
un libkb.NormalizedUsername, sibkeys, subkeys []keybase1.KID, err error) {
u.log.Debug("+ GetUser")
defer func() {
u.log.Debug("- GetUser -> %v", err)
}()
var ukr userKeyRes
err = u.api.GetDecode(libkb.APIArg{
Endpoint: "user/keys",
Args: libkb.HTTPArgs{
"uid": libkb.S{Val: uid.String()},
},
}, &ukr)
if err != nil {
return "", nil, nil, err
}
un = libkb.NewNormalizedUsername(ukr.Username)
return un, ukr.PublicKeys.Sibkeys, ukr.PublicKeys.Subkeys, nil
}
func DbKeyUID(t ObjType, uid keybase1.UID) DbKey {
return DbKey{Typ: t, Key: uid.String()}
}
func UIDArg(uid keybase1.UID) HTTPValue {
return S{Val: uid.String()}
}
func UIDWrapper(uid keybase1.UID) *jsonw.Wrapper {
return jsonw.NewString(uid.String())
}
