ProfileView viewer for following and blocking state

main.go

···
 	} else {
 		didtest = &didval
 	}
-	profiletest, _, _ := appbskyactordefs.ProfileViewBasic(ctx, *didtest, sl, BSKYIMAGECDN_URL)
+	profiletest, _, _ := appbskyactordefs.ProfileViewBasic(ctx, *didtest, sl, cs, BSKYIMAGECDN_URL, nil)
 
 	log.Println(*profiletest.DisplayName)
 	log.Println(*profiletest.Avatar)
···
 
 	bskyappdid, _ := utils.NewDID("did:plc:z72i7hdynmk6r22z27h6tvur")
 
-	profiletest2, _, _ := appbskyactordefs.ProfileViewDetailed(ctx, bskyappdid, sl, cs, BSKYIMAGECDN_URL)
+	profiletest2, _, _ := appbskyactordefs.ProfileViewDetailed(ctx, bskyappdid, sl, cs, BSKYIMAGECDN_URL, nil)
 
 	data, err := json.MarshalIndent(profiletest2, "", "  ")
 	if err != nil {
···
 		func(c *gin.Context) {
 			actors := c.QueryArray("actors")
 
+			rawdid := c.GetString("user_did")
+			var viewer *utils.DID
+			didval, errdid := utils.NewDID(rawdid)
+			if errdid != nil {
+				viewer = nil
+			} else {
+				viewer = &didval
+			}
+
 			profiles := make([]*appbsky.ActorDefs_ProfileViewDetailed, 0, len(actors))
 
 			for _, v := range actors {
···
 				if err != nil {
 					continue
 				}
-				profile, _, _ := appbskyactordefs.ProfileViewDetailed(ctx, did, sl, cs, BSKYIMAGECDN_URL)
+				profile, _, _ := appbskyactordefs.ProfileViewDetailed(ctx, did, sl, cs, BSKYIMAGECDN_URL, viewer)
 				profiles = append(profiles, profile)
 			}
 
···
 				c.JSON(http.StatusBadRequest, nil)
 				return
 			}
-			profile, _, _ := appbskyactordefs.ProfileViewDetailed(ctx, did, sl, cs, BSKYIMAGECDN_URL)
+			rawdid := c.GetString("user_did")
+			var viewer *utils.DID
+			didval, errdid := utils.NewDID(rawdid)
+			if errdid != nil {
+				viewer = nil
+			} else {
+				viewer = &didval
+			}
+			profile, _, _ := appbskyactordefs.ProfileViewDetailed(ctx, did, sl, cs, BSKYIMAGECDN_URL, viewer)
 			c.JSON(http.StatusOK, profile)
 		})
 
···
 				if err != nil {
 					continue
 				}
-				labelerprofile, _, _ := appbskyactordefs.ProfileView(ctx, did, sl, BSKYIMAGECDN_URL)
+				rawdid := c.GetString("user_did")
+				var viewer *utils.DID
+				didval, errdid := utils.NewDID(rawdid)
+				if errdid != nil {
+					viewer = nil
+				} else {
+					viewer = &didval
+				}
+				labelerprofile, _, _ := appbskyactordefs.ProfileView(ctx, did, sl, cs, BSKYIMAGECDN_URL, viewer)
 				labelerserviceresponse, _ := agnostic.RepoGetRecord(ctx, sl, "", "app.bsky.labeler.service", string(did), "self")
 				var labelerservice appbsky.LabelerService
 				if labelerserviceresponse != nil {
···
 					if err != nil {
 						return
 					}
+					rawdid := c.GetString("user_did")
+					var viewer *utils.DID
+					didval, errdid := utils.NewDID(rawdid)
+					if errdid != nil {
+						viewer = nil
+					} else {
+						viewer = &didval
+					}
 
 					// fetch profile and record in parallel too (optional)
 					// but to keep it simple, do serial inside this goroutine
-					profile, _, _ := appbskyactordefs.ProfileView(ctx, repoDID, sl, BSKYIMAGECDN_URL)
+					profile, _, _ := appbskyactordefs.ProfileView(ctx, repoDID, sl, cs, BSKYIMAGECDN_URL, viewer)
 
 					rec, err := agnostic.RepoGetRecord(ctx, sl, "", collection, did, rkey)
 					if err != nil || rec.Value == nil {

shims/lex/app/bsky/actor/defs/profileview.go

···
 import (
 	"context"
 	"encoding/json"
+	"log"
 
 	"github.com/bluesky-social/indigo/api/agnostic"
 	appbsky "github.com/bluesky-social/indigo/api/bsky"
+	"github.com/bluesky-social/indigo/atproto/syntax"
 	"tangled.org/whey.party/red-dwarf-server/microcosm"
 	"tangled.org/whey.party/red-dwarf-server/microcosm/constellation"
 	"tangled.org/whey.party/red-dwarf-server/microcosm/slingshot"
 	"tangled.org/whey.party/red-dwarf-server/shims/utils"
 )
 
-func ProfileViewBasic(ctx context.Context, did utils.DID, sl *microcosm.MicrocosmClient, imgcdn string) (*appbsky.ActorDefs_ProfileViewBasic, *appbsky.ActorProfile, error) {
-	profileview, profile, err := ProfileView(ctx, did, sl, imgcdn)
+func ProfileViewBasic(ctx context.Context, did utils.DID, sl *microcosm.MicrocosmClient, cs *microcosm.MicrocosmClient, imgcdn string, viewer *utils.DID) (*appbsky.ActorDefs_ProfileViewBasic, *appbsky.ActorProfile, error) {
+	profileview, profile, err := ProfileView(ctx, did, sl, cs, imgcdn, viewer)
 
 	if err != nil {
 		return nil, nil, err
···
 	}, profile, err
 }
 
-func ProfileView(ctx context.Context, did utils.DID, sl *microcosm.MicrocosmClient, imgcdn string) (*appbsky.ActorDefs_ProfileView, *appbsky.ActorProfile, error) {
+func ProfileView(ctx context.Context, did utils.DID, sl *microcosm.MicrocosmClient, cs *microcosm.MicrocosmClient, imgcdn string, viewer *utils.DID) (*appbsky.ActorDefs_ProfileView, *appbsky.ActorProfile, error) {
 	identity, err_i := slingshot.ResolveMiniDoc(ctx, sl, string(did))
 	if err_i != nil {
 		identity = nil
···
 		avatar = &url
 	}
 
+	var blocking *string
+	blockedBy := false
+	var following *string
+	var followedBy *string
+
+	viewerProfileDID := ""
+	if viewer != nil {
+		viewerProfileDID = string(*viewer)
+	}
+	targetProfileDID := string(did)
+	//viewerProfileURI, err_viewerProfileURI := syntax.ParseATURI("at://" + viewerProfileDID + "/app.bsky.actor.profile/self")
+	//targetProfileURI, err_targetProfileURI := syntax.ParseATURI("at://" + targetProfileDID + "/app.bsky.actor.profile/self")
+
+	log.Println("viewerProfileDID: " + viewerProfileDID + " and targetProfileDID: " + targetProfileDID)
+
+	if viewerProfileDID != "" && targetProfileDID != "" {
+		blockingBacklink, err_blockingBacklink := constellation.GetBacklinks(ctx, cs, targetProfileDID, "app.bsky.graph.block:subject", []string{viewerProfileDID}, nil, nil)
+		if err_blockingBacklink == nil && blockingBacklink.Records != nil && len(blockingBacklink.Records) > 0 && blockingBacklink.Total > 0 {
+			blockingATURI, err_blockingATURI := syntax.ParseATURI("at://" + blockingBacklink.Records[0].Did + "/app.bsky.graph.block/" + blockingBacklink.Records[0].Rkey)
+			if err_blockingATURI == nil {
+				blockingString := blockingATURI.String()
+				blocking = &blockingString
+			}
+		}
+		blockedByBacklink, err_blockedByBacklink := constellation.GetBacklinks(ctx, cs, viewerProfileDID, "app.bsky.graph.block:subject", []string{targetProfileDID}, nil, nil)
+		if err_blockedByBacklink == nil && blockedByBacklink.Records != nil && len(blockedByBacklink.Records) > 0 && blockedByBacklink.Total > 0 {
+			_, err_blockedByATURI := syntax.ParseATURI("at://" + blockedByBacklink.Records[0].Did + "/app.bsky.graph.block/" + blockedByBacklink.Records[0].Rkey)
+			if err_blockedByATURI == nil {
+				blockedBy = true
+			}
+		}
+		followingBacklink, err_followingBacklink := constellation.GetBacklinks(ctx, cs, targetProfileDID, "app.bsky.graph.follow:subject", []string{viewerProfileDID}, nil, nil)
+		if err_followingBacklink == nil && followingBacklink.Records != nil && len(followingBacklink.Records) > 0 && followingBacklink.Total > 0 {
+			followingATURI, err_followingATURI := syntax.ParseATURI("at://" + followingBacklink.Records[0].Did + "/app.bsky.graph.follow/" + followingBacklink.Records[0].Rkey)
+			if err_followingATURI == nil {
+				followingString := followingATURI.String()
+				following = &followingString
+			}
+		}
+		followedByBacklink, err_followedByBacklink := constellation.GetBacklinks(ctx, cs, viewerProfileDID, "app.bsky.graph.follow:subject", []string{targetProfileDID}, nil, nil)
+		if err_followedByBacklink == nil && followedByBacklink.Records != nil && len(followedByBacklink.Records) > 0 && followedByBacklink.Total > 0 {
+			followedByATURI, err_followedByATURI := syntax.ParseATURI("at://" + followedByBacklink.Records[0].Did + "/app.bsky.graph.follow/" + followedByBacklink.Records[0].Rkey)
+			if err_followedByATURI == nil {
+				followedByString := followedByATURI.String()
+				followedBy = &followedByString
+			}
+		}
+
+	}
+
+	// we dont know before hand, so to make it visible on the page, we must set it to be non zero
+	nonzeroassociated := int64(1)
+
 	return &appbsky.ActorDefs_ProfileView{
-		Associated:   nil,
+		Associated: &appbsky.ActorDefs_ProfileAssociated{
+			// ActivitySubscription *ActorDefs_ProfileAssociatedActivitySubscription `json:"activitySubscription,omitempty" cborgen:"activitySubscription,omitempty"`
+			// Chat                 *ActorDefs_ProfileAssociatedChat                 `json:"chat,omitempty" cborgen:"chat,omitempty"`
+			// Feedgens             *int64                                           `json:"feedgens,omitempty" cborgen:"feedgens,omitempty"`
+			Feedgens: &nonzeroassociated,
+			// Labeler              *bool                                            `json:"labeler,omitempty" cborgen:"labeler,omitempty"`
+			// Lists                *int64                                           `json:"lists,omitempty" cborgen:"lists,omitempty"`
+			Lists: &nonzeroassociated,
+			// StarterPacks         *int64                                           `json:"starterPacks,omitempty" cborgen:"starterPacks,omitempty"`
+			StarterPacks: &nonzeroassociated,
+		},
 		Avatar:       avatar,
 		CreatedAt:    profile.CreatedAt,
 		Debug:        nil,
···
 		Pronouns:     nil,
 		Status:       nil,
 		Verification: nil,
-		Viewer:       nil,
+		Viewer: &appbsky.ActorDefs_ViewerState{
+			// // activitySubscription: This property is present only in selected cases, as an optimization.
+			// ActivitySubscription *NotificationDefs_ActivitySubscription `json:"activitySubscription,omitempty" cborgen:"activitySubscription,omitempty"`
+			// BlockedBy            *bool                                  `json:"blockedBy,omitempty" cborgen:"blockedBy,omitempty"`
+			BlockedBy: &blockedBy,
+			// Blocking             *string                                `json:"blocking,omitempty" cborgen:"blocking,omitempty"`
+			Blocking: blocking,
+			// BlockingByList       *GraphDefs_ListViewBasic               `json:"blockingByList,omitempty" cborgen:"blockingByList,omitempty"`
+			// FollowedBy           *string                                `json:"followedBy,omitempty" cborgen:"followedBy,omitempty"`
+			FollowedBy: followedBy,
+			// Following            *string                                `json:"following,omitempty" cborgen:"following,omitempty"`
+			Following: following,
+			// // knownFollowers: This property is present only in selected cases, as an optimization.
+			// KnownFollowers *ActorDefs_KnownFollowers `json:"knownFollowers,omitempty" cborgen:"knownFollowers,omitempty"`
+			// Muted          *bool                     `json:"muted,omitempty" cborgen:"muted,omitempty"`
+			// MutedByList    *GraphDefs_ListViewBasic  `json:"mutedByList,omitempty" cborgen:"mutedByList,omitempty"`
+		},
 	}, &profile, nil
 }
 
-func ProfileViewDetailed(ctx context.Context, did utils.DID, sl *microcosm.MicrocosmClient, cs *microcosm.MicrocosmClient, imgcdn string) (*appbsky.ActorDefs_ProfileViewDetailed, *appbsky.ActorProfile, error) {
-	profileview, profile, err := ProfileView(ctx, did, sl, imgcdn)
+func ProfileViewDetailed(ctx context.Context, did utils.DID, sl *microcosm.MicrocosmClient, cs *microcosm.MicrocosmClient, imgcdn string, viewer *utils.DID) (*appbsky.ActorDefs_ProfileViewDetailed, *appbsky.ActorProfile, error) {
+	profileview, profile, err := ProfileView(ctx, did, sl, cs, imgcdn, viewer)
 	if err != nil {
 		return nil, nil, err
 	}

shims/lex/app/bsky/feed/defs/embed.go

···
 
 	if collection == "app.bsky.feed.post" {
 		//t.EmbedRecord_ViewRecord.LexiconTypeID = "app.bsky.embed.record#viewRecord"
-		profileViewBasic, _, err := appbskyactordefs.ProfileViewBasic(ctx, utils.DID(aturi.Authority().String()), sl, imgcdn)
+		profileViewBasic, _, err := appbskyactordefs.ProfileViewBasic(ctx, utils.DID(aturi.Authority().String()), sl, cs, imgcdn, viewer)
 		if err != nil {
 			log.Println("[EmbedRecord_View_Record] profileviewbasic failed")
 			return notFoundRecordEmbed(aturi.String())

shims/lex/app/bsky/feed/defs/postview.go

···
 	}
 	//}
 
-	profile, _, err := appbskyactordefs.ProfileViewBasic(ctx, repoDID, sl, imgcdn)
+	profile, _, err := appbskyactordefs.ProfileViewBasic(ctx, repoDID, sl, cs, imgcdn, viewer)
 	if err != nil || profile == nil {
 		if profile == nil {
 			//log.Println("WHAT!! profile / author field is null?!?!?! whyyy")