func (h *UserHandler) LoadUser(_ context.Context, arg keybase1.LoadUserArg) (user keybase1.User, err error) {
loadUserArg := libkb.NewLoadUserByUIDArg(h.G(), arg.Uid)
loadUserArg.PublicKeyOptional = true
u, err := libkb.LoadUser(loadUserArg)
if err != nil {
return
}
exportedUser := u.Export()
user = *exportedUser
return
}
func (h IdentifyUIHandler) handleShowTrackerPopupDismiss(ctx context.Context, cli gregor1.IncomingInterface,
item gregor.Item) error {
h.G().Log.Debug("handleShowTrackerPopupDismiss: %+v", item)
if item.Body() == nil {
return errors.New("gregor dismissal for show_tracker_popup: nil message body")
}
body, err := jsonw.Unmarshal(item.Body().Bytes())
if err != nil {
h.G().Log.Debug("body failed to unmarshal", err)
return err
}
uidString, err := body.AtPath("uid").GetString()
if err != nil {
h.G().Log.Debug("failed to extract uid", err)
return err
}
uid, err := keybase1.UIDFromString(uidString)
if err != nil {
h.G().Log.Debug("failed to convert UID from string", err)
return err
}
user, err := libkb.LoadUser(libkb.NewLoadUserByUIDArg(h.G(), uid))
if err != nil {
h.G().Log.Debug("failed to load user from UID", err)
return err
}
identifyUI, err := h.G().UIRouter.GetIdentifyUI()
if err != nil {
h.G().Log.Debug("failed to get IdentifyUI", err)
return err
}
if identifyUI == nil {
h.G().Log.Debug("got nil IdentifyUI")
return errors.New("got nil IdentifyUI")
}
reason := keybase1.DismissReason{
Type: keybase1.DismissReasonType_HANDLED_ELSEWHERE,
}
identifyUI.Dismiss(user.GetName(), reason)
return nil
}
func (e *TrackEngine) Run(ctx *Context) error {
arg := &keybase1.Identify2Arg{
UserAssertion: e.arg.UserAssertion,
ForceRemoteCheck: e.arg.ForceRemoteCheck,
NeedProofSet: true,
NoErrorOnTrackFailure: true,
}
ieng := NewResolveThenIdentify2WithTrack(e.G(), arg, e.arg.Options)
if err := RunEngine(ieng, ctx); err != nil {
return err
}
upk := ieng.Result().Upk
var err error
e.them, err = libkb.LoadUser(libkb.NewLoadUserByUIDArg(e.G(), upk.Uid))
if err != nil {
return err
}
confirmResult := ieng.ConfirmResult()
if !confirmResult.IdentityConfirmed {
e.G().Log.Debug("confirmResult: %+v", confirmResult)
return errors.New("Track not confirmed")
}
// if they didn't specify local only on the command line, then if they answer no to posting
// the tracking statement publicly to keybase, change LocalOnly to true here:
if !e.arg.Options.LocalOnly && !confirmResult.RemoteConfirmed {
e.arg.Options.LocalOnly = true
}
if !e.arg.Options.ExpiringLocal && confirmResult.ExpiringLocal {
e.G().Log.Debug("-ExpiringLocal-")
e.arg.Options.ExpiringLocal = true
}
targ := &TrackTokenArg{
Token: ieng.TrackToken(),
Me: e.arg.Me,
Options: e.arg.Options,
}
teng := NewTrackToken(targ, e.G())
return RunEngine(teng, ctx)
}