commit cd5978098742aba204ce956ed36e7d7b1a5995d3 · ptr.pet/bsky-repost-likes

+59 -36

server/main.go

···

       7
       7
        
       	"log/slog"

     

       8
       8
        
       	"net/http"

     

       9
       9
        
       	"sync/atomic"

     

       10
       10
       +
       	"time"

     

       10
       11
        
       

     

       11
       12
        
       	"github.com/bluesky-social/indigo/api/bsky"

     

       12
       13
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     
···

       25
       26
        
       const ListenTypeFollows = "follows"

     

       26
       27
        
       

     

       27
       28
        
       type SubscriberData struct {

     

       28
       28
       -
       	ForActor   syntax.DID

     

       29
       29
       -
       	Conn       *websocket.Conn

     

       30
       30
       -
       	ListenType string

     

       31
       31
       -
       	ListenTo   Set[syntax.DID]

     

       29
       29
       +
       	forActor   syntax.DID

     

       30
       30
       +
       	conn       *websocket.Conn

     

       31
       31
       +
       	listenType string

     

       32
       32
       +
       	listenTo   Set[syntax.DID]

     

       32
       33
        
       }

     

       33
       34
        
       

     

       34
       35
        
       type ActorData struct {

     

       35
       35
       -
       	targets       *hashmap.Map[string, *SubscriberData]

     

       36
       36
       -
       	likes         map[syntax.RecordKey]bsky.FeedLike

     

       37
       37
       -
       	follows       *hashmap.Map[syntax.RecordKey, bsky.GraphFollow]

     

       38
       38
       -
       	followsCursor atomic.Pointer[string]

     

       36
       36
       +
       	targets          *hashmap.Map[string, *SubscriberData]

     

       37
       37
       +
       	likes            map[syntax.RecordKey]bsky.FeedLike

     

       38
       38
       +
       	follows          *hashmap.Map[syntax.RecordKey, bsky.GraphFollow]

     

       39
       39
       +
       	followsCursor    atomic.Pointer[string]

     

       40
       40
       +
       	profile          *bsky.ActorDefs_ProfileViewDetailed

     

       41
       41
       +
       	profileFetchedAt time.Time

     

       42
       42
       +
       }

     

       43
       43
       +
       

     

       44
       44
       +
       type NotificationActor struct {

     

       45
       45
       +
       	DID     syntax.DID                          `json:"did"`     // the DID of the actor that (un)liked the post

     

       46
       46
       +
       	Profile *bsky.ActorDefs_ProfileViewDetailed `json:"profile"` // the detailed profile of the actor that (un)liked the post

     

       39
       47
        
       }

     

       40
       48
        
       

     

       41
       49
        
       type NotificationMessage struct {

     

       42
       42
       -
       	Liked     bool         `json:"liked"`

     

       43
       43
       -
       	ByDid     syntax.DID   `json:"did"`

     

       44
       44
       -
       	RepostURI syntax.ATURI `json:"repost_uri"`

     

       45
       45
       -
       	PostURI   syntax.ATURI `json:"post_uri"`

     

       50
       50
       +
       	Liked  bool              `json:"liked"`  // whether the message was liked or unliked

     

       51
       51
       +
       	Actor  NotificationActor `json:"actor"`  // information about the actor that (un)liked

     

       52
       52
       +
       	Record bsky.FeedLike     `json:"record"` // the raw like record

     

       53
       53
       +
       	Time   int64             `json:"time"`   // when the like event came in

     

       46
       54
        
       }

     

       47
       55
        
       

     

       48
       56
        
       type SubscriberMessage struct {

     
···

       75
       83
        
       func getSubscriberDids() []string {

     

       76
       84
        
       	_dids := make(Set[string], subscribers.Len())

     

       77
       85
        
       	subscribers.Range(func(s string, sd *SubscriberData) bool {

     

       78
       78
       -
       		_dids[string(sd.ForActor)] = struct{}{}

     

       86
       86
       +
       		_dids[string(sd.forActor)] = struct{}{}

     

       79
       87
        
       		return true

     

       80
       88
        
       	})

     

       81
       89
        
       	dids := make([]string, 0, len(_dids))

     
···

       159
       167
        
       

     

       160
       168
        
       	ud := getActorData(did)

     

       161
       169
        
       	sd := &SubscriberData{

     

       162
       162
       -
       		ForActor:   did,

     

       163
       163
       -
       		Conn:       conn,

     

       164
       164
       -
       		ListenType: listenType,

     

       170
       170
       +
       		forActor:   did,

     

       171
       171
       +
       		conn:       conn,

     

       172
       172
       +
       		listenType: listenType,

     

       165
       173
        
       	}

     

       166
       174
        
       

     

       167
       175
        
       	switch listenType {

     
···

       171
       179
        
       			logger.Error("error fetching follows", "error", err)

     

       172
       180
        
       			return

     

       173
       181
        
       		}

     

       174
       174
       -
       		sd.ListenTo = make(Set[syntax.DID])

     

       182
       182
       +
       		sd.listenTo = make(Set[syntax.DID])

     

       175
       183
        
       		// use we have stored

     

       176
       184
        
       		ud.follows.Range(func(rk syntax.RecordKey, f bsky.GraphFollow) bool {

     

       177
       177
       -
       			sd.ListenTo[syntax.DID(f.Subject)] = struct{}{}

     

       185
       185
       +
       			sd.listenTo[syntax.DID(f.Subject)] = struct{}{}

     

       178
       186
        
       			return true

     

       179
       187
        
       		})

     

       180
       188
        
       		if len(follows) > 0 {

     
···

       182
       190
        
       			ud.followsCursor.Store((*string)(&follows[len(follows)-1].rkey))

     

       183
       191
        
       			for _, f := range follows {

     

       184
       192
        
       				ud.follows.Insert(f.rkey, f.follow)

     

       185
       185
       -
       				sd.ListenTo[syntax.DID(f.follow.Subject)] = struct{}{}

     

       193
       193
       +
       				sd.listenTo[syntax.DID(f.follow.Subject)] = struct{}{}

     

       186
       194
        
       			}

     

       187
       195
        
       		}

     

       188
       196
        
       		logger.Info("fetched follows")

     

       189
       197
        
       	case ListenTypeNone:

     

       190
       190
       -
       		sd.ListenTo = make(Set[syntax.DID])

     

       198
       198
       +
       		sd.listenTo = make(Set[syntax.DID])

     

       191
       199
        
       	default:

     

       192
       200
        
       		http.Error(w, "invalid listen type", http.StatusBadRequest)

     

       193
       201
        
       		return

     

       194
       202
        
       	}

     

       195
       203
        
       

     

       196
       204
        
       	subscribers.Set(sid, sd)

     

       197
       197
       -
       	for listenDid := range sd.ListenTo {

     

       205
       205
       +
       	for listenDid := range sd.listenTo {

     

       198
       206
        
       		markActorForLikes(sid, sd, listenDid)

     

       199
       207
        
       	}

     

       200
       208
        
       	updateFollowStreamOpts()

     

       201
       209
        
       	// delete subscriber after we are done

     

       202
       210
        
       	defer func() {

     

       203
       203
       -
       		for listenDid := range sd.ListenTo {

     

       211
       211
       +
       		for listenDid := range sd.listenTo {

     

       204
       212
        
       			unmarkActorForLikes(sid, listenDid)

     

       205
       213
        
       		}

     

       206
       214
        
       		subscribers.Del(sid)

     
···

       219
       227
        
       		switch msg.Type {

     

       220
       228
        
       		case "update_listen_to":

     

       221
       229
        
       			// only allow this if we arent managing listen to

     

       222
       222
       -
       			if sd.ListenType != ListenTypeNone {

     

       230
       230
       +
       			if sd.listenType != ListenTypeNone {

     

       223
       231
        
       				continue

     

       224
       232
        
       			}

     

       225
       233
        
       

     
···

       229
       237
        
       				break

     

       230
       238
        
       			}

     

       231
       239
        
       			// remove all current listens and add the ones the user requested

     

       232
       232
       -
       			for listenDid := range sd.ListenTo {

     

       240
       240
       +
       			for listenDid := range sd.listenTo {

     

       233
       241
        
       				unmarkActorForLikes(sid, listenDid)

     

       234
       234
       -
       				delete(sd.ListenTo, listenDid)

     

       242
       242
       +
       				delete(sd.listenTo, listenDid)

     

       235
       243
        
       			}

     

       236
       244
        
       			for _, listenDid := range innerMsg.ListenTo {

     

       237
       237
       -
       				sd.ListenTo[listenDid] = struct{}{}

     

       245
       245
       +
       				sd.listenTo[listenDid] = struct{}{}

     

       238
       246
        
       				markActorForLikes(sid, sd, listenDid)

     

       239
       247
        
       			}

     

       240
       248
        
       		}

     
···

       276
       284
        
       		return nil

     

       277
       285
        
       	}

     

       278
       286
        
       

     

       287
       287
       +
       	logger := logger.With("actor", byDid, "type", "like")

     

       288
       288
       +
       

     

       279
       289
        
       	deleted := event.Commit.Operation == models.CommitOperationDelete

     

       280
       290
        
       	rkey := syntax.RecordKey(event.Commit.RKey)

     

       281
       291
        
       

     
···

       315
       325
        
       		return err

     

       316
       326
        
       	}

     

       317
       327
        
       	ud.targets.Range(func(sid string, sd *SubscriberData) bool {

     

       318
       318
       -
       		if sd.ForActor != reposterDID {

     

       328
       328
       +
       		if sd.forActor != reposterDID {

     

       319
       329
        
       			return true

     

       320
       330
        
       		}

     

       321
       331
        
       

     

       332
       332
       +
       		if ud.profile == nil || time.Now().Sub(ud.profileFetchedAt) > time.Hour*24 {

     

       333
       333
       +
       			profile, err := fetchProfile(ctx, byDid)

     

       334
       334
       +
       			if err != nil {

     

       335
       335
       +
       				logger.Error("cant fetch profile", "error", err)

     

       336
       336
       +
       			} else {

     

       337
       337
       +
       				ud.profile = profile

     

       338
       338
       +
       				ud.profileFetchedAt = time.Now()

     

       339
       339
       +
       			}

     

       340
       340
       +
       		}

     

       341
       341
       +
       

     

       322
       342
        
       		notification := NotificationMessage{

     

       323
       323
       -
       			Liked:     !deleted,

     

       324
       324
       -
       			ByDid:     byDid,

     

       325
       325
       -
       			RepostURI: repostURI,

     

       326
       326
       -
       			PostURI:   syntax.ATURI(like.Subject.Uri),

     

       343
       343
       +
       			Liked: !deleted,

     

       344
       344
       +
       			Actor: NotificationActor{

     

       345
       345
       +
       				DID:     byDid,

     

       346
       346
       +
       				Profile: ud.profile,

     

       347
       347
       +
       			},

     

       348
       348
       +
       			Record: like,

     

       349
       349
       +
       			Time:   event.TimeUS,

     

       327
       350
        
       		}

     

       328
       351
        
       

     

       329
       329
       -
       		if err := sd.Conn.WriteJSON(notification); err != nil {

     

       330
       330
       -
       			logger.Error("failed to send notification", "subscriber", sd.ForActor, "error", err)

     

       352
       352
       +
       		if err := sd.conn.WriteJSON(notification); err != nil {

     

       353
       353
       +
       			logger.Error("failed to send notification", "error", err)

     

       331
       354
        
       		}

     

       332
       355
        
       		return true

     

       333
       356
        
       	})

     
···

       369
       392
        
       		}

     

       370
       393
        
       		ud.targets.Range(func(sid string, sd *SubscriberData) bool {

     

       371
       394
        
       			// if we arent managing then we dont need to update anything

     

       372
       372
       -
       			if sd.ListenType != ListenTypeFollows {

     

       395
       395
       +
       			if sd.listenType != ListenTypeFollows {

     

       373
       396
        
       				return true

     

       374
       397
        
       			}

     

       375
       398
        
       			subjectDid := syntax.DID(r.Subject)

     

       376
       399
        
       			if deleted {

     

       377
       400
        
       				unmarkActorForLikes(sid, subjectDid)

     

       378
       378
       -
       				delete(sd.ListenTo, subjectDid)

     

       401
       401
       +
       				delete(sd.listenTo, subjectDid)

     

       379
       402
        
       			} else {

     

       380
       380
       -
       				sd.ListenTo[subjectDid] = struct{}{}

     

       403
       403
       +
       				sd.listenTo[subjectDid] = struct{}{}

     

       381
       404
        
       				markActorForLikes(sid, sd, subjectDid)

     

       382
       405
        
       			}

     

       383
       406
        
       			return true

+2 -11

server/xrpc.go

···

       10
       10
        
       	"github.com/bluesky-social/indigo/atproto/identity"

     

       11
       11
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       12
       12
        
       	"github.com/bluesky-social/indigo/xrpc"

     

       13
       13
       -
       	"github.com/bluesky-social/jetstream/pkg/models"

     

       14
       13
        
       )

     

       15
       14
        
       

     

       16
       15
        
       func findUserPDS(ctx context.Context, did syntax.DID) (string, error) {

     
···

       26
       25
        
       	return pdsURI, nil

     

       27
       26
        
       }

     

       28
       27
        
       

     

       29
       29
       -
       func fetchRecord[v any](ctx context.Context, xrpcClient *xrpc.Client, val *v, event *models.Event) error {

     

       30
       30
       -
       	out, err := atproto.RepoGetRecord(ctx, xrpcClient, "", event.Commit.Collection, event.Did, event.Commit.RKey)

     

       31
       31
       -
       	if err != nil {

     

       32
       32
       -
       		return err

     

       33
       33
       -
       	}

     

       34
       34
       -
       	raw, _ := out.Value.MarshalJSON()

     

       35
       35
       -
       	if err := json.Unmarshal(raw, val); err != nil {

     

       36
       36
       -
       		return err

     

       37
       37
       -
       	}

     

       38
       38
       -
       	return nil

     

       28
       28
       +
       func fetchProfile(ctx context.Context, did syntax.DID) (*bsky.ActorDefs_ProfileViewDetailed, error) {

     

       29
       29
       +
       	return bsky.ActorGetProfile(ctx, &xrpc.Client{Host: "https://public.api.bsky.app"}, string(did))

     

       39
       30
        
       }

     

       40
       31
        
       

     

       41
       32
        
       func fetchRecords[v any](ctx context.Context, xrpcClient *xrpc.Client, cb func(syntax.ATURI, v), cursor *string, collection string, did syntax.DID) error {

+20 -61

webapp/src/ActivityItem.tsx

···

       1
       1
       -
       import { Did, Handle } from "@atcute/lexicons";

     

       2
       2
       -
       import { Client, ok, simpleFetchHandler } from "@atcute/client";

     

       3
       1
        
       import type {} from "@atcute/bluesky";

     

       4
       2
        
       import type {} from "@atcute/atproto";

     

       5
       5
       -
       import { isDid, parseCanonicalResourceUri } from "@atcute/lexicons/syntax";

     

       3
       3
       +
       import { parseCanonicalResourceUri } from "@atcute/lexicons/syntax";

     

       6
       4
        
       import { Component, createSignal, createEffect } from "solid-js";

     

       7
       7
       -
       import { ATProtoActivity } from "./types.js";

     

       8
       8
       -
       

     

       9
       9
       -
       const profileCache = new Map<string, ActorData>();

     

       10
       10
       -
       const handler = simpleFetchHandler({

     

       11
       11
       -
         service: "https://public.api.bsky.app",

     

       12
       12
       -
       });

     

       13
       13
       -
       const rpc = new Client({ handler });

     

       5
       5
       +
       import { Notification } from "./types.js";

     

       14
       6
        
       

     

       15
       7
        
       interface ActivityItemProps {

     

       16
       16
       -
         data: ATProtoActivity;

     

       17
       17
       -
       }

     

       18
       18
       -
       

     

       19
       19
       -
       interface ActorData {

     

       20
       20
       -
         did: Did;

     

       21
       21
       -
         handle: Handle;

     

       22
       22
       -
         displayName?: string;

     

       8
       8
       +
         data: Notification;

     

       23
       9
        
       }

     

       24
       10
        
       

     

       25
       11
        
       export const ActivityItem: Component<ActivityItemProps> = (props) => {

     

       26
       26
       -
         const [actorData, setActorData] = createSignal<ActorData | null>(null);

     

       27
       27
       -
         const [error, setError] = createSignal<string | null>(null);

     

       28
       12
        
         const [postUrl, setPostUrl] = createSignal<string | null>(null);

     

       29
       13
        
       

     

       30
       30
       -
         const fetchProfile = async (did: string) => {

     

       31
       31
       -
           if (!isDid(did)) {

     

       32
       32
       -
             setError("user DID invalid");

     

       33
       33
       -
             return;

     

       34
       34
       -
           }

     

       35
       35
       -
           const resp = ok(

     

       36
       36
       -
             await rpc.get("app.bsky.actor.getProfile", {

     

       37
       37
       -
               params: { actor: did },

     

       38
       38
       -
             }),

     

       39
       39
       -
           );

     

       40
       40
       -
           const data: ActorData = {

     

       41
       41
       -
             did,

     

       42
       42
       -
             handle: resp.handle,

     

       43
       43
       -
             displayName: resp.displayName,

     

       44
       44
       -
           };

     

       45
       45
       -
           setActorData(data);

     

       46
       46
       -
           profileCache.set(data.did, data);

     

       47
       47
       -
         };

     

       14
       14
       +
         const profile = props.data.actor.profile;

     

       48
       15
        
       

     

       49
       16
        
         createEffect(() => {

     

       50
       50
       -
           const actorData = profileCache.get(props.data.did);

     

       51
       51
       -
           if (actorData) {

     

       52
       52
       -
             setActorData(actorData);

     

       53
       53
       -
           } else {

     

       54
       54
       -
             fetchProfile(props.data.did);

     

       55
       55
       -
           }

     

       56
       56
       -
       

     

       57
       57
       -
           const postUri = parseCanonicalResourceUri(props.data.post_uri);

     

       17
       17
       +
           const postUri = parseCanonicalResourceUri(

     

       18
       18
       +
             props.data.record.subject?.uri ?? "",

     

       19
       19
       +
           );

     

       58
       20
        
           if (postUri.ok) {

     

       59
       21
        
             setPostUrl(

     

       60
       22
        
               `https://bsky.app/profile/${postUri.value.repo}/post/${postUri.value.rkey}`,

     
···

       72
       34
        
           >

     

       73
       35
        
             <p text-wrap>

     

       74
       36
        
               <span text-lg>{props.data.liked ? "❤️" : "💔"}</span>{" "}

     

       75
       75
       -
               {(actorData() && (

     

       37
       37
       +
               {(profile && (

     

       76
       38
        
                 <span font-medium text="sm gray-700">

     

       77
       77
       -
                   {actorData()!.displayName ?? actorData()!.handle}{" "}

     

       78
       78
       -
                   {actorData()!.displayName && (

     

       39
       39
       +
                   {profile!.displayName ?? profile!.handle}{" "}

     

       40
       40
       +
                   {profile!.displayName && (

     

       79
       41
        
                     <span font-normal text-gray-500>

     

       80
       80
       -
                       (@{actorData()!.handle})

     

       42
       42
       +
                       (@{profile!.handle})

     

       81
       43
        
                     </span>

     

       82
       44
        
                   )}

     

       83
       45
        
                 </span>

     

       84
       84
       -
               )) ||

     

       85
       85
       -
                 (error() && (

     

       86
       86
       -
                   <span italic text="xs red-500">

     

       87
       87
       -
                     !{error()}!

     

       88
       88
       -
                   </span>

     

       89
       89
       -
                 )) || (

     

       90
       90
       -
                   <span font-medium text="sm gray-700">

     

       91
       91
       -
                     {props.data.did}

     

       92
       92
       -
                   </span>

     

       93
       93
       -
                 )}{" "}

     

       46
       46
       +
               )) || (

     

       47
       47
       +
                 <span font-medium text="sm gray-700">

     

       48
       48
       +
                   {props.data.actor.did}

     

       49
       49
       +
                 </span>

     

       50
       50
       +
               )}{" "}

     

       94
       51
        
               <span text-gray-800>{props.data.liked ? "liked" : "unliked"}</span>{" "}

     

       95
       52
        
               <a

     

       96
       53
        
                 text-blue-800

     

       97
       54
        
                 hover="underline text-blue-400"

     

       98
       98
       -
                 href={postUrl() ?? props.data.post_uri}

     

       55
       55
       +
                 href={postUrl() ?? props.data.record.subject?.uri}

     

       99
       56
        
               >

     

       100
       57
        
                 this post

     

       101
       58
        
               </a>{" "}

     

       102
       59
        
             </p>

     

       103
       60
        
             <div grow />

     

       104
       104
       -
             <div text="xs gray-500 end">{new Date().toLocaleTimeString()}</div>

     

       61
       61
       +
             <div text="xs gray-500 end">

     

       62
       62
       +
               {new Date(props.data.time / 1000).toLocaleTimeString()}

     

       63
       63
       +
             </div>

     

       105
       64
        
           </div>

     

       106
       65
        
         );

     

       107
       66
        
       };

+10 -4

webapp/src/App.tsx

···

       4
       4
        
       import type {} from "@atcute/atproto";

     

       5
       5
        
       import { isDid, isHandle } from "@atcute/lexicons/syntax";

     

       6
       6
        
       import { XrpcHandleResolver } from "@atcute/identity-resolver";

     

       7
       7
       -
       import { ATProtoActivity } from "./types.js";

     

       7
       7
       +
       import { Notification } from "./types.js";

     

       8
       8
        
       import { ActivityItem } from "./ActivityItem.jsx";

     

       9
       9
        
       

     

       10
       10
        
       const handleResolver = new XrpcHandleResolver({

     
···

       15
       15
        
         const [actorId, setActorId] = createSignal<string>("");

     

       16
       16
        
         const [serviceDomain, setWsUrl] = createSignal<string>("likes.gaze.systems");

     

       17
       17
        
         const [isConnected, setIsConnected] = createSignal<boolean>(false);

     

       18
       18
       -
         const [items, setItems] = createSignal<ATProtoActivity[]>([]);

     

       18
       18
       +
         const [items, setItems] = createSignal<Notification[]>([]);

     

       19
       19
        
         const [connectionStatus, setConnectionStatus] = createSignal<

     

       20
       20
        
           "disconnected" | "connecting..." | "connected" | "error"

     

       21
       21
        
         >("disconnected");

     
···

       62
       62
        
             ws.close();

     

       63
       63
        
           }

     

       64
       64
        
       

     

       65
       65
       -
           const url = `wss://${host}/subscribe/${did}`;

     

       65
       65
       +
           let proto = "wss";

     

       66
       66
       +
           const domain = host.split(":").at(0) ?? "";

     

       67
       67
       +
           if (["localhost", "0.0.0.0", "127.0.0.1"].some((v) => v === domain)) {

     

       68
       68
       +
             proto = "ws";

     

       69
       69
       +
           }

     

       70
       70
       +
       

     

       71
       71
       +
           const url = `${proto}://${host}/subscribe/${did}`;

     

       66
       72
        
       

     

       67
       73
        
           try {

     

       68
       74
        
             ws = new WebSocket(url);

     
···

       76
       82
        
       

     

       77
       83
        
             ws.onmessage = (event: MessageEvent) => {

     

       78
       84
        
               try {

     

       79
       79
       -
                 const data: ATProtoActivity = JSON.parse(event.data);

     

       85
       85
       +
                 const data: Notification = JSON.parse(event.data);

     

       80
       86
        
                 setItems((prev) => [data, ...prev]); // add new items to the top

     

       81
       87
        
               } catch (error) {

     

       82
       88
        
                 console.error("Error parsing JSON:", error);

+13 -4

webapp/src/types.ts

···

       1
       1
       -
       export interface ATProtoActivity {

     

       2
       2
       -
         did: string;

     

       1
       1
       +
       import { AppBskyFeedLike } from "@atcute/bluesky";

     

       2
       2
       +
       import { ProfileViewDetailed } from "@atcute/bluesky/types/app/actor/defs";

     

       3
       3
       +
       import { Did } from "@atcute/lexicons";

     

       4
       4
       +
       

     

       5
       5
       +
       export interface Notification {

     

       3
       6
        
         liked: boolean;

     

       4
       4
       -
         repost_uri: string;

     

       5
       5
       -
         post_uri: string;

     

       7
       7
       +
         actor: NotificationActor;

     

       8
       8
       +
         record: AppBskyFeedLike.Main;

     

       9
       9
       +
         time: number;

     

       10
       10
       +
       }

     

       11
       11
       +
       

     

       12
       12
       +
       export interface NotificationActor {

     

       13
       13
       +
         did: Did;

     

       14
       14
       +
         profile?: ProfileViewDetailed;

     

       6
       15
        
       }