func (c *CmdSearch) showJSONResults(results []keybase1.UserSummary) error {
output := jsonw.NewArray(len(results))
for userIndex, user := range results {
userBlob := jsonw.NewDictionary()
userBlob.SetKey("username", jsonw.NewString(user.Username))
for _, social := range user.Proofs.Social {
userBlob.SetKey(social.ProofType, jsonw.NewString(social.ProofName))
}
if len(user.Proofs.Web) > 0 {
var webProofs []string
for _, webProof := range user.Proofs.Web {
for _, protocol := range webProof.Protocols {
webProofs = append(webProofs, libkb.MakeURI(protocol, webProof.Hostname))
}
}
websites := jsonw.NewArray(len(webProofs))
for i, wp := range webProofs {
websites.SetIndex(i, jsonw.NewString(wp))
}
userBlob.SetKey("websites", websites)
}
output.SetIndex(userIndex, userBlob)
}
GlobUI.Println(output.MarshalPretty())
return nil
}
func (e *ListTrackingEngine) runJSON(trackList TrackList, verbose bool) error {
var tmp []*jsonw.Wrapper
for _, link := range trackList {
var rec *jsonw.Wrapper
var e2 error
if verbose {
rec = link.GetPayloadJSON()
} else if rec, e2 = condenseRecord(link); e2 != nil {
e.G().Log.Warning("In conversion to JSON: %s", e2)
}
if e2 == nil {
tmp = append(tmp, rec)
}
}
ret := jsonw.NewArray(len(tmp))
for i, r := range tmp {
if err := ret.SetIndex(i, r); err != nil {
return err
}
}
e.jsonResult = ret.MarshalPretty()
return nil
}
func (sh SigHints) MarshalToJSON() *jsonw.Wrapper {
ret := jsonw.NewDictionary()
ret.SetKey("version", jsonw.NewInt(sh.version))
ret.SetKey("hints", jsonw.NewArray(len(sh.hints)))
i := 0
for _, v := range sh.hints {
ret.AtKey("hints").SetIndex(i, v.MarshalToJSON())
i++
}
return ret
}
func createKeyFamily(bundles []string) (*KeyFamily, error) {
allKeys := jsonw.NewArray(len(bundles))
for i, bundle := range bundles {
err := allKeys.SetIndex(i, jsonw.NewString(bundle))
if err != nil {
return nil, err
}
}
publicKeys := jsonw.NewDictionary()
publicKeys.SetKey("all_bundles", allKeys)
return ParseKeyFamily(publicKeys)
}
// TrackingStatement generates the remote proofs portions of the
// tracking statement from the active proofs.
func (r *RemoteProofLinks) TrackingStatement() *jsonw.Wrapper {
var proofs []*jsonw.Wrapper
for _, x := range r.active() {
d, err := x.link.ToTrackingStatement(x.state)
if err != nil {
G.Log.Warning("Problem with a proof: %s", err)
continue
}
if d != nil {
proofs = append(proofs, d)
}
}
res := jsonw.NewArray(len(proofs))
for i, proof := range proofs {
res.SetIndex(i, proof)
}
return res
}
func (u *User) RevokeSigsProof(key GenericKey, sigIDsToRevoke []keybase1.SigID) (*jsonw.Wrapper, error) {
ret, err := ProofMetadata{
Me: u,
LinkType: RevokeType,
SigningKey: key,
}.ToJSON(u.G())
if err != nil {
return nil, err
}
body := ret.AtKey("body")
revokeSection := jsonw.NewDictionary()
idsArray := jsonw.NewArray(len(sigIDsToRevoke))
for i, id := range sigIDsToRevoke {
idsArray.SetIndex(i, jsonw.NewString(id.ToString(true)))
}
revokeSection.SetKey("sig_ids", idsArray)
body.SetKey("revoke", revokeSection)
return ret, nil
}
func (u *User) ToTrackingStatementPGPKeys(errp *error) *jsonw.Wrapper {
keys := u.GetActivePGPKeys(true)
if len(keys) == 0 {
return nil
}
ret := jsonw.NewArray(len(keys))
for i, k := range keys {
kd := jsonw.NewDictionary()
kid := k.GetKID()
fp := k.GetFingerprintP()
kd.SetKey("kid", jsonw.NewString(kid.String()))
if fp != nil {
kd.SetKey("key_fingerprint", jsonw.NewString(fp.String()))
}
ret.SetIndex(i, kd)
}
return ret
}
