···

       
11
       
 
       


     

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

     

       
13
       
 
       
	"tangled.org/core/api/tangled"

     

       
0
       
 
       

     

       
14
       
 
       
	"tangled.org/core/appview/pagination"

     

       
15
       
 
       
)

     

       
16
       
 
       


     
···

       
30
       
 
       
	// optionally, populate this when querying for reverse mappings

     

       
31
       
 
       
	// like comment counts, parent repo etc.

     

       
32
       
 
       
	Comments []IssueComment

     

       
33
       
-
       
	Labels   LabelState

     

       
34
       
 
       
	Repo     *Repo

     

       
35
       
 
       
}

     

       
36
       
 
       


     

···

       
11
       
 
       


     

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

     

       
13
       
 
       
	"tangled.org/core/api/tangled"

     

       
14
       
+
       
	"tangled.org/core/appview/models"

     

       
15
       
 
       
	"tangled.org/core/appview/pagination"

     

       
16
       
 
       
)

     

       
17
       
 
       


     
···

       
31
       
 
       
	// optionally, populate this when querying for reverse mappings

     

       
32
       
 
       
	// like comment counts, parent repo etc.

     

       
33
       
 
       
	Comments []IssueComment

     

       
34
       
+
       
	Labels   models.LabelState

     

       
35
       
 
       
	Repo     *Repo

     

       
36
       
 
       
}

     

       
37
       
 
       


     

···

       
1
       
 
       
package db

     

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
-
       
	"crypto/sha1"

     

       
5
       
 
       
	"database/sql"

     

       
6
       
-
       
	"encoding/hex"

     

       
7
       
-
       
	"errors"

     

       
8
       
 
       
	"fmt"

     

       
9
       
 
       
	"maps"

     

       
10
       
 
       
	"slices"

     
···

       
12
       
 
       
	"time"

     

       
13
       
 
       


     

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

     

       
15
       
-
       
	"tangled.sh/tangled.sh/core/api/tangled"

     

       
16
       
-
       
	"tangled.sh/tangled.sh/core/consts"

     

       
17
       
-
       
)

     

       
18
       
-
       


     

       
19
       
-
       
type ConcreteType string

     

       
20
       
-
       


     

       
21
       
-
       
const (

     

       
22
       
-
       
	ConcreteTypeNull   ConcreteType = "null"

     

       
23
       
-
       
	ConcreteTypeString ConcreteType = "string"

     

       
24
       
-
       
	ConcreteTypeInt    ConcreteType = "integer"

     

       
25
       
-
       
	ConcreteTypeBool   ConcreteType = "boolean"

     

       
26
       
-
       
)

     

       
27
       
-
       


     

       
28
       
-
       
type ValueTypeFormat string

     

       
29
       
-
       


     

       
30
       
-
       
const (

     

       
31
       
-
       
	ValueTypeFormatAny ValueTypeFormat = "any"

     

       
32
       
-
       
	ValueTypeFormatDid ValueTypeFormat = "did"

     

       
33
       
 
       
)

     

       
34
       
 
       


     

       
35
       
-
       
// ValueType represents an atproto lexicon type definition with constraints

     

       
36
       
-
       
type ValueType struct {

     

       
37
       
-
       
	Type   ConcreteType    `json:"type"`

     

       
38
       
-
       
	Format ValueTypeFormat `json:"format,omitempty"`

     

       
39
       
-
       
	Enum   []string        `json:"enum,omitempty"`

     

       
40
       
-
       
}

     

       
41
       
-
       


     

       
42
       
-
       
func (vt *ValueType) AsRecord() tangled.LabelDefinition_ValueType {

     

       
43
       
-
       
	return tangled.LabelDefinition_ValueType{

     

       
44
       
-
       
		Type:   string(vt.Type),

     

       
45
       
-
       
		Format: string(vt.Format),

     

       
46
       
-
       
		Enum:   vt.Enum,

     

       
47
       
-
       
	}

     

       
48
       
-
       
}

     

       
49
       
-
       


     

       
50
       
-
       
func ValueTypeFromRecord(record tangled.LabelDefinition_ValueType) ValueType {

     

       
51
       
-
       
	return ValueType{

     

       
52
       
-
       
		Type:   ConcreteType(record.Type),

     

       
53
       
-
       
		Format: ValueTypeFormat(record.Format),

     

       
54
       
-
       
		Enum:   record.Enum,

     

       
55
       
-
       
	}

     

       
56
       
-
       
}

     

       
57
       
-
       


     

       
58
       
-
       
func (vt ValueType) IsConcreteType() bool {

     

       
59
       
-
       
	return vt.Type == ConcreteTypeNull ||

     

       
60
       
-
       
		vt.Type == ConcreteTypeString ||

     

       
61
       
-
       
		vt.Type == ConcreteTypeInt ||

     

       
62
       
-
       
		vt.Type == ConcreteTypeBool

     

       
63
       
-
       
}

     

       
64
       
-
       


     

       
65
       
-
       
func (vt ValueType) IsNull() bool {

     

       
66
       
-
       
	return vt.Type == ConcreteTypeNull

     

       
67
       
-
       
}

     

       
68
       
-
       


     

       
69
       
-
       
func (vt ValueType) IsString() bool {

     

       
70
       
-
       
	return vt.Type == ConcreteTypeString

     

       
71
       
-
       
}

     

       
72
       
-
       


     

       
73
       
-
       
func (vt ValueType) IsInt() bool {

     

       
74
       
-
       
	return vt.Type == ConcreteTypeInt

     

       
75
       
-
       
}

     

       
76
       
-
       


     

       
77
       
-
       
func (vt ValueType) IsBool() bool {

     

       
78
       
-
       
	return vt.Type == ConcreteTypeBool

     

       
79
       
-
       
}

     

       
80
       
-
       


     

       
81
       
-
       
func (vt ValueType) IsEnum() bool {

     

       
82
       
-
       
	return len(vt.Enum) > 0

     

       
83
       
-
       
}

     

       
84
       
-
       


     

       
85
       
-
       
func (vt ValueType) IsDidFormat() bool {

     

       
86
       
-
       
	return vt.Format == ValueTypeFormatDid

     

       
87
       
-
       
}

     

       
88
       
-
       


     

       
89
       
-
       
func (vt ValueType) IsAnyFormat() bool {

     

       
90
       
-
       
	return vt.Format == ValueTypeFormatAny

     

       
91
       
-
       
}

     

       
92
       
-
       


     

       
93
       
-
       
type LabelDefinition struct {

     

       
94
       
-
       
	Id   int64

     

       
95
       
-
       
	Did  string

     

       
96
       
-
       
	Rkey string

     

       
97
       
-
       


     

       
98
       
-
       
	Name      string

     

       
99
       
-
       
	ValueType ValueType

     

       
100
       
-
       
	Scope     []string

     

       
101
       
-
       
	Color     *string

     

       
102
       
-
       
	Multiple  bool

     

       
103
       
-
       
	Created   time.Time

     

       
104
       
-
       
}

     

       
105
       
-
       


     

       
106
       
-
       
func (l *LabelDefinition) AtUri() syntax.ATURI {

     

       
107
       
-
       
	return syntax.ATURI(fmt.Sprintf("at://%s/%s/%s", l.Did, tangled.LabelDefinitionNSID, l.Rkey))

     

       
108
       
-
       
}

     

       
109
       
-
       


     

       
110
       
-
       
func (l *LabelDefinition) AsRecord() tangled.LabelDefinition {

     

       
111
       
-
       
	vt := l.ValueType.AsRecord()

     

       
112
       
-
       
	return tangled.LabelDefinition{

     

       
113
       
-
       
		Name:      l.Name,

     

       
114
       
-
       
		Color:     l.Color,

     

       
115
       
-
       
		CreatedAt: l.Created.Format(time.RFC3339),

     

       
116
       
-
       
		Multiple:  &l.Multiple,

     

       
117
       
-
       
		Scope:     l.Scope,

     

       
118
       
-
       
		ValueType: &vt,

     

       
119
       
-
       
	}

     

       
120
       
-
       
}

     

       
121
       
-
       


     

       
122
       
-
       
// random color for a given seed

     

       
123
       
-
       
func randomColor(seed string) string {

     

       
124
       
-
       
	hash := sha1.Sum([]byte(seed))

     

       
125
       
-
       
	hexStr := hex.EncodeToString(hash[:])

     

       
126
       
-
       
	r := hexStr[0:2]

     

       
127
       
-
       
	g := hexStr[2:4]

     

       
128
       
-
       
	b := hexStr[4:6]

     

       
129
       
-
       


     

       
130
       
-
       
	return fmt.Sprintf("#%s%s%s", r, g, b)

     

       
131
       
-
       
}

     

       
132
       
-
       


     

       
133
       
-
       
func (ld LabelDefinition) GetColor() string {

     

       
134
       
-
       
	if ld.Color == nil {

     

       
135
       
-
       
		seed := fmt.Sprintf("%d:%s:%s", ld.Id, ld.Did, ld.Rkey)

     

       
136
       
-
       
		color := randomColor(seed)

     

       
137
       
-
       
		return color

     

       
138
       
-
       
	}

     

       
139
       
-
       


     

       
140
       
-
       
	return *ld.Color

     

       
141
       
-
       
}

     

       
142
       
-
       


     

       
143
       
-
       
func LabelDefinitionFromRecord(did, rkey string, record tangled.LabelDefinition) (*LabelDefinition, error) {

     

       
144
       
-
       
	created, err := time.Parse(time.RFC3339, record.CreatedAt)

     

       
145
       
-
       
	if err != nil {

     

       
146
       
-
       
		created = time.Now()

     

       
147
       
-
       
	}

     

       
148
       
-
       


     

       
149
       
-
       
	multiple := false

     

       
150
       
-
       
	if record.Multiple != nil {

     

       
151
       
-
       
		multiple = *record.Multiple

     

       
152
       
-
       
	}

     

       
153
       
-
       


     

       
154
       
-
       
	var vt ValueType

     

       
155
       
-
       
	if record.ValueType != nil {

     

       
156
       
-
       
		vt = ValueTypeFromRecord(*record.ValueType)

     

       
157
       
-
       
	}

     

       
158
       
-
       


     

       
159
       
-
       
	return &LabelDefinition{

     

       
160
       
-
       
		Did:  did,

     

       
161
       
-
       
		Rkey: rkey,

     

       
162
       
-
       


     

       
163
       
-
       
		Name:      record.Name,

     

       
164
       
-
       
		ValueType: vt,

     

       
165
       
-
       
		Scope:     record.Scope,

     

       
166
       
-
       
		Color:     record.Color,

     

       
167
       
-
       
		Multiple:  multiple,

     

       
168
       
-
       
		Created:   created,

     

       
169
       
-
       
	}, nil

     

       
170
       
-
       
}

     

       
171
       
-
       


     

       
172
       
-
       
func DeleteLabelDefinition(e Execer, filters ...filter) error {

     

       
173
       
-
       
	var conditions []string

     

       
174
       
-
       
	var args []any

     

       
175
       
-
       
	for _, filter := range filters {

     

       
176
       
-
       
		conditions = append(conditions, filter.Condition())

     

       
177
       
-
       
		args = append(args, filter.Arg()...)

     

       
178
       
-
       
	}

     

       
179
       
-
       
	whereClause := ""

     

       
180
       
-
       
	if conditions != nil {

     

       
181
       
-
       
		whereClause = " where " + strings.Join(conditions, " and ")

     

       
182
       
-
       
	}

     

       
183
       
-
       
	query := fmt.Sprintf(`delete from label_definitions %s`, whereClause)

     

       
184
       
-
       
	_, err := e.Exec(query, args...)

     

       
185
       
-
       
	return err

     

       
186
       
-
       
}

     

       
187
       
-
       


     

       
188
       
 
       
// no updating type for now

     

       
189
       
-
       
func AddLabelDefinition(e Execer, l *LabelDefinition) (int64, error) {

     

       
190
       
 
       
	result, err := e.Exec(

     

       
191
       
 
       
		`insert into label_definitions (

     

       
192
       
 
       
			did,

     
···

       
232
       
 
       
	return id, nil

     

       
233
       
 
       
}

     

       
234
       
 
       


     

       
235
       
-
       
func GetLabelDefinitions(e Execer, filters ...filter) ([]LabelDefinition, error) {

     

       
236
       
-
       
	var labelDefinitions []LabelDefinition

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
237
       
 
       
	var conditions []string

     

       
238
       
 
       
	var args []any

     

       
239
       
 
       


     
···

       
275
       
 
       
	defer rows.Close()

     

       
276
       
 
       


     

       
277
       
 
       
	for rows.Next() {

     

       
278
       
-
       
		var labelDefinition LabelDefinition

     

       
279
       
 
       
		var createdAt, enumVariants, scopes string

     

       
280
       
 
       
		var color sql.Null[string]

     

       
281
       
 
       
		var multiple int

     
···

       
324
       
 
       
}

     

       
325
       
 
       


     

       
326
       
 
       
// helper to get exactly one label def

     

       
327
       
-
       
func GetLabelDefinition(e Execer, filters ...filter) (*LabelDefinition, error) {

     

       
328
       
 
       
	labels, err := GetLabelDefinitions(e, filters...)

     

       
329
       
 
       
	if err != nil {

     

       
330
       
 
       
		return nil, err

     
···

       
341
       
 
       
	return &labels[0], nil

     

       
342
       
 
       
}

     

       
343
       
 
       


     

       
344
       
-
       
type LabelOp struct {

     

       
345
       
-
       
	Id           int64

     

       
346
       
-
       
	Did          string

     

       
347
       
-
       
	Rkey         string

     

       
348
       
-
       
	Subject      syntax.ATURI

     

       
349
       
-
       
	Operation    LabelOperation

     

       
350
       
-
       
	OperandKey   string

     

       
351
       
-
       
	OperandValue string

     

       
352
       
-
       
	PerformedAt  time.Time

     

       
353
       
-
       
	IndexedAt    time.Time

     

       
354
       
-
       
}

     

       
355
       
-
       


     

       
356
       
-
       
func (l LabelOp) SortAt() time.Time {

     

       
357
       
-
       
	createdAt := l.PerformedAt

     

       
358
       
-
       
	indexedAt := l.IndexedAt

     

       
359
       
-
       


     

       
360
       
-
       
	// if we don't have an indexedat, fall back to now

     

       
361
       
-
       
	if indexedAt.IsZero() {

     

       
362
       
-
       
		indexedAt = time.Now()

     

       
363
       
-
       
	}

     

       
364
       
-
       


     

       
365
       
-
       
	// if createdat is invalid (before epoch), treat as null -> return zero time

     

       
366
       
-
       
	if createdAt.Before(time.UnixMicro(0)) {

     

       
367
       
-
       
		return time.Time{}

     

       
368
       
-
       
	}

     

       
369
       
-
       


     

       
370
       
-
       
	// if createdat is <= indexedat, use createdat

     

       
371
       
-
       
	if createdAt.Before(indexedAt) || createdAt.Equal(indexedAt) {

     

       
372
       
-
       
		return createdAt

     

       
373
       
-
       
	}

     

       
374
       
-
       


     

       
375
       
-
       
	// otherwise, createdat is in the future relative to indexedat -> use indexedat

     

       
376
       
-
       
	return indexedAt

     

       
377
       
-
       
}

     

       
378
       
-
       


     

       
379
       
-
       
type LabelOperation string

     

       
380
       
-
       


     

       
381
       
-
       
const (

     

       
382
       
-
       
	LabelOperationAdd LabelOperation = "add"

     

       
383
       
-
       
	LabelOperationDel LabelOperation = "del"

     

       
384
       
-
       
)

     

       
385
       
-
       


     

       
386
       
-
       
// a record can create multiple label ops

     

       
387
       
-
       
func LabelOpsFromRecord(did, rkey string, record tangled.LabelOp) []LabelOp {

     

       
388
       
-
       
	performed, err := time.Parse(time.RFC3339, record.PerformedAt)

     

       
389
       
-
       
	if err != nil {

     

       
390
       
-
       
		performed = time.Now()

     

       
391
       
-
       
	}

     

       
392
       
-
       


     

       
393
       
-
       
	mkOp := func(operand *tangled.LabelOp_Operand) LabelOp {

     

       
394
       
-
       
		return LabelOp{

     

       
395
       
-
       
			Did:          did,

     

       
396
       
-
       
			Rkey:         rkey,

     

       
397
       
-
       
			Subject:      syntax.ATURI(record.Subject),

     

       
398
       
-
       
			OperandKey:   operand.Key,

     

       
399
       
-
       
			OperandValue: operand.Value,

     

       
400
       
-
       
			PerformedAt:  performed,

     

       
401
       
-
       
		}

     

       
402
       
-
       
	}

     

       
403
       
-
       


     

       
404
       
-
       
	var ops []LabelOp

     

       
405
       
-
       
	for _, o := range record.Add {

     

       
406
       
-
       
		if o != nil {

     

       
407
       
-
       
			op := mkOp(o)

     

       
408
       
-
       
			op.Operation = LabelOperationAdd

     

       
409
       
-
       
			ops = append(ops, op)

     

       
410
       
-
       
		}

     

       
411
       
-
       
	}

     

       
412
       
-
       
	for _, o := range record.Delete {

     

       
413
       
-
       
		if o != nil {

     

       
414
       
-
       
			op := mkOp(o)

     

       
415
       
-
       
			op.Operation = LabelOperationDel

     

       
416
       
-
       
			ops = append(ops, op)

     

       
417
       
-
       
		}

     

       
418
       
-
       
	}

     

       
419
       
-
       


     

       
420
       
-
       
	return ops

     

       
421
       
-
       
}

     

       
422
       
-
       


     

       
423
       
-
       
func LabelOpsAsRecord(ops []LabelOp) tangled.LabelOp {

     

       
424
       
-
       
	if len(ops) == 0 {

     

       
425
       
-
       
		return tangled.LabelOp{}

     

       
426
       
-
       
	}

     

       
427
       
-
       


     

       
428
       
-
       
	// use the first operation to establish common fields

     

       
429
       
-
       
	first := ops[0]

     

       
430
       
-
       
	record := tangled.LabelOp{

     

       
431
       
-
       
		Subject:     string(first.Subject),

     

       
432
       
-
       
		PerformedAt: first.PerformedAt.Format(time.RFC3339),

     

       
433
       
-
       
	}

     

       
434
       
-
       


     

       
435
       
-
       
	var addOperands []*tangled.LabelOp_Operand

     

       
436
       
-
       
	var deleteOperands []*tangled.LabelOp_Operand

     

       
437
       
-
       


     

       
438
       
-
       
	for _, op := range ops {

     

       
439
       
-
       
		operand := &tangled.LabelOp_Operand{

     

       
440
       
-
       
			Key:   op.OperandKey,

     

       
441
       
-
       
			Value: op.OperandValue,

     

       
442
       
-
       
		}

     

       
443
       
-
       


     

       
444
       
-
       
		switch op.Operation {

     

       
445
       
-
       
		case LabelOperationAdd:

     

       
446
       
-
       
			addOperands = append(addOperands, operand)

     

       
447
       
-
       
		case LabelOperationDel:

     

       
448
       
-
       
			deleteOperands = append(deleteOperands, operand)

     

       
449
       
-
       
		default:

     

       
450
       
-
       
			return tangled.LabelOp{}

     

       
451
       
-
       
		}

     

       
452
       
-
       
	}

     

       
453
       
-
       


     

       
454
       
-
       
	record.Add = addOperands

     

       
455
       
-
       
	record.Delete = deleteOperands

     

       
456
       
-
       


     

       
457
       
-
       
	return record

     

       
458
       
-
       
}

     

       
459
       
-
       


     

       
460
       
-
       
func AddLabelOp(e Execer, l *LabelOp) (int64, error) {

     

       
461
       
 
       
	now := time.Now()

     

       
462
       
 
       
	result, err := e.Exec(

     

       
463
       
 
       
		`insert into label_ops (

     
···

       
500
       
 
       
	return id, nil

     

       
501
       
 
       
}

     

       
502
       
 
       


     

       
503
       
-
       
func GetLabelOps(e Execer, filters ...filter) ([]LabelOp, error) {

     

       
504
       
-
       
	var labelOps []LabelOp

     

       
505
       
 
       
	var conditions []string

     

       
506
       
 
       
	var args []any

     

       
507
       
 
       


     
···

       
541
       
 
       
	defer rows.Close()

     

       
542
       
 
       


     

       
543
       
 
       
	for rows.Next() {

     

       
544
       
-
       
		var labelOp LabelOp

     

       
545
       
 
       
		var performedAt, indexedAt string

     

       
546
       
 
       


     

       
547
       
 
       
		if err := rows.Scan(

     
···

       
575
       
 
       
}

     

       
576
       
 
       


     

       
577
       
 
       
// get labels for a given list of subject URIs

     

       
578
       
-
       
func GetLabels(e Execer, filters ...filter) (map[syntax.ATURI]LabelState, error) {

     

       
579
       
 
       
	ops, err := GetLabelOps(e, filters...)

     

       
580
       
 
       
	if err != nil {

     

       
581
       
 
       
		return nil, err

     

       
582
       
 
       
	}

     

       
583
       
 
       


     

       
584
       
 
       
	// group ops by subject

     

       
585
       
-
       
	opsBySubject := make(map[syntax.ATURI][]LabelOp)

     

       
586
       
 
       
	for _, op := range ops {

     

       
587
       
 
       
		subject := syntax.ATURI(op.Subject)

     

       
588
       
 
       
		opsBySubject[subject] = append(opsBySubject[subject], op)

     
···

       
601
       
 
       
	}

     

       
602
       
 
       


     

       
603
       
 
       
	// apply label ops for each subject and collect results

     

       
604
       
-
       
	results := make(map[syntax.ATURI]LabelState)

     

       
605
       
 
       
	for subject, subjectOps := range opsBySubject {

     

       
606
       
-
       
		state := NewLabelState()

     

       
607
       
 
       
		actx.ApplyLabelOps(state, subjectOps)

     

       
608
       
 
       
		results[subject] = state

     

       
609
       
 
       
	}

     
···

       
611
       
 
       
	return results, nil

     

       
612
       
 
       
}

     

       
613
       
 
       


     

       
614
       
-
       
type set = map[string]struct{}

     

       
615
       
-
       


     

       
616
       
-
       
type LabelState struct {

     

       
617
       
-
       
	inner map[string]set

     

       
618
       
-
       
}

     

       
619
       
-
       


     

       
620
       
-
       
func NewLabelState() LabelState {

     

       
621
       
-
       
	return LabelState{

     

       
622
       
-
       
		inner: make(map[string]set),

     

       
623
       
-
       
	}

     

       
624
       
-
       
}

     

       
625
       
-
       


     

       
626
       
-
       
func (s LabelState) Inner() map[string]set {

     

       
627
       
-
       
	return s.inner

     

       
628
       
-
       
}

     

       
629
       
-
       


     

       
630
       
-
       
func (s LabelState) ContainsLabel(l string) bool {

     

       
631
       
-
       
	if valset, exists := s.inner[l]; exists {

     

       
632
       
-
       
		if valset != nil {

     

       
633
       
-
       
			return true

     

       
634
       
-
       
		}

     

       
635
       
-
       
	}

     

       
636
       
-
       


     

       
637
       
-
       
	return false

     

       
638
       
-
       
}

     

       
639
       
-
       


     

       
640
       
-
       
// go maps behavior in templates make this necessary,

     

       
641
       
-
       
// indexing a map and getting `set` in return is apparently truthy

     

       
642
       
-
       
func (s LabelState) ContainsLabelAndVal(l, v string) bool {

     

       
643
       
-
       
	if valset, exists := s.inner[l]; exists {

     

       
644
       
-
       
		if _, exists := valset[v]; exists {

     

       
645
       
-
       
			return true

     

       
646
       
-
       
		}

     

       
647
       
-
       
	}

     

       
648
       
-
       


     

       
649
       
-
       
	return false

     

       
650
       
-
       
}

     

       
651
       
-
       


     

       
652
       
-
       
func (s LabelState) GetValSet(l string) set {

     

       
653
       
-
       
	if valset, exists := s.inner[l]; exists {

     

       
654
       
-
       
		return valset

     

       
655
       
-
       
	} else {

     

       
656
       
-
       
		return make(set)

     

       
657
       
-
       
	}

     

       
658
       
-
       
}

     

       
659
       
-
       


     

       
660
       
-
       
type LabelApplicationCtx struct {

     

       
661
       
-
       
	Defs map[string]*LabelDefinition // labelAt -> labelDef

     

       
662
       
-
       
}

     

       
663
       
-
       


     

       
664
       
-
       
var (

     

       
665
       
-
       
	LabelNoOpError = errors.New("no-op")

     

       
666
       
-
       
)

     

       
667
       
-
       


     

       
668
       
-
       
func NewLabelApplicationCtx(e Execer, filters ...filter) (*LabelApplicationCtx, error) {

     

       
669
       
 
       
	labels, err := GetLabelDefinitions(e, filters...)

     

       
670
       
 
       
	if err != nil {

     

       
671
       
 
       
		return nil, err

     

       
672
       
 
       
	}

     

       
673
       
 
       


     

       
674
       
-
       
	defs := make(map[string]*LabelDefinition)

     

       
675
       
 
       
	for _, l := range labels {

     

       
676
       
 
       
		defs[l.AtUri().String()] = &l

     

       
677
       
 
       
	}

     

       
678
       
 
       


     

       
679
       
-
       
	return &LabelApplicationCtx{defs}, nil

     

       
680
       
-
       
}

     

       
681
       
-
       


     

       
682
       
-
       
func (c *LabelApplicationCtx) ApplyLabelOp(state LabelState, op LabelOp) error {

     

       
683
       
-
       
	def, ok := c.Defs[op.OperandKey]

     

       
684
       
-
       
	if !ok {

     

       
685
       
-
       
		// this def was deleted, but an op exists, so we just skip over the op

     

       
686
       
-
       
		return nil

     

       
687
       
-
       
	}

     

       
688
       
-
       


     

       
689
       
-
       
	switch op.Operation {

     

       
690
       
-
       
	case LabelOperationAdd:

     

       
691
       
-
       
		// if valueset is empty, init it

     

       
692
       
-
       
		if state.inner[op.OperandKey] == nil {

     

       
693
       
-
       
			state.inner[op.OperandKey] = make(set)

     

       
694
       
-
       
		}

     

       
695
       
-
       


     

       
696
       
-
       
		// if valueset is populated & this val alr exists, this labelop is a noop

     

       
697
       
-
       
		if valueSet, exists := state.inner[op.OperandKey]; exists {

     

       
698
       
-
       
			if _, exists = valueSet[op.OperandValue]; exists {

     

       
699
       
-
       
				return LabelNoOpError

     

       
700
       
-
       
			}

     

       
701
       
-
       
		}

     

       
702
       
-
       


     

       
703
       
-
       
		if def.Multiple {

     

       
704
       
-
       
			// append to set

     

       
705
       
-
       
			state.inner[op.OperandKey][op.OperandValue] = struct{}{}

     

       
706
       
-
       
		} else {

     

       
707
       
-
       
			// reset to just this value

     

       
708
       
-
       
			state.inner[op.OperandKey] = set{op.OperandValue: struct{}{}}

     

       
709
       
-
       
		}

     

       
710
       
-
       


     

       
711
       
-
       
	case LabelOperationDel:

     

       
712
       
-
       
		// if label DNE, then deletion is a no-op

     

       
713
       
-
       
		if valueSet, exists := state.inner[op.OperandKey]; !exists {

     

       
714
       
-
       
			return LabelNoOpError

     

       
715
       
-
       
		} else if _, exists = valueSet[op.OperandValue]; !exists { // if value DNE, then deletion is no-op

     

       
716
       
-
       
			return LabelNoOpError

     

       
717
       
-
       
		}

     

       
718
       
-
       


     

       
719
       
-
       
		if def.Multiple {

     

       
720
       
-
       
			// remove from set

     

       
721
       
-
       
			delete(state.inner[op.OperandKey], op.OperandValue)

     

       
722
       
-
       
		} else {

     

       
723
       
-
       
			// reset the entire label

     

       
724
       
-
       
			delete(state.inner, op.OperandKey)

     

       
725
       
-
       
		}

     

       
726
       
-
       


     

       
727
       
-
       
		// if the map becomes empty, then set it to nil, this is just the inverse of add

     

       
728
       
-
       
		if len(state.inner[op.OperandKey]) == 0 {

     

       
729
       
-
       
			state.inner[op.OperandKey] = nil

     

       
730
       
-
       
		}

     

       
731
       
-
       


     

       
732
       
-
       
	}

     

       
733
       
-
       


     

       
734
       
-
       
	return nil

     

       
735
       
-
       
}

     

       
736
       
-
       


     

       
737
       
-
       
func (c *LabelApplicationCtx) ApplyLabelOps(state LabelState, ops []LabelOp) {

     

       
738
       
-
       
	// sort label ops in sort order first

     

       
739
       
-
       
	slices.SortFunc(ops, func(a, b LabelOp) int {

     

       
740
       
-
       
		return a.SortAt().Compare(b.SortAt())

     

       
741
       
-
       
	})

     

       
742
       
-
       


     

       
743
       
-
       
	// apply ops in sequence

     

       
744
       
-
       
	for _, o := range ops {

     

       
745
       
-
       
		_ = c.ApplyLabelOp(state, o)

     

       
746
       
-
       
	}

     

       
747
       
-
       
}

     

       
748
       
-
       


     

       
749
       
-
       
// IsInverse checks if one label operation is the inverse of another

     

       
750
       
-
       
// returns true if one is an add and the other is a delete with the same key and value

     

       
751
       
-
       
func (op1 LabelOp) IsInverse(op2 LabelOp) bool {

     

       
752
       
-
       
	if op1.OperandKey != op2.OperandKey || op1.OperandValue != op2.OperandValue {

     

       
753
       
-
       
		return false

     

       
754
       
-
       
	}

     

       
755
       
-
       


     

       
756
       
-
       
	return (op1.Operation == LabelOperationAdd && op2.Operation == LabelOperationDel) ||

     

       
757
       
-
       
		(op1.Operation == LabelOperationDel && op2.Operation == LabelOperationAdd)

     

       
758
       
-
       
}

     

       
759
       
-
       


     

       
760
       
-
       
// removes pairs of label operations that are inverses of each other

     

       
761
       
-
       
// from the given slice. the function preserves the order of remaining operations.

     

       
762
       
-
       
func ReduceLabelOps(ops []LabelOp) []LabelOp {

     

       
763
       
-
       
	if len(ops) <= 1 {

     

       
764
       
-
       
		return ops

     

       
765
       
-
       
	}

     

       
766
       
-
       


     

       
767
       
-
       
	keep := make([]bool, len(ops))

     

       
768
       
-
       
	for i := range keep {

     

       
769
       
-
       
		keep[i] = true

     

       
770
       
-
       
	}

     

       
771
       
-
       


     

       
772
       
-
       
	for i := range ops {

     

       
773
       
-
       
		if !keep[i] {

     

       
774
       
-
       
			continue

     

       
775
       
-
       
		}

     

       
776
       
-
       


     

       
777
       
-
       
		for j := i + 1; j < len(ops); j++ {

     

       
778
       
-
       
			if !keep[j] {

     

       
779
       
-
       
				continue

     

       
780
       
-
       
			}

     

       
781
       
-
       


     

       
782
       
-
       
			if ops[i].IsInverse(ops[j]) {

     

       
783
       
-
       
				keep[i] = false

     

       
784
       
-
       
				keep[j] = false

     

       
785
       
-
       
				break // move to next i since this one is now eliminated

     

       
786
       
-
       
			}

     

       
787
       
-
       
		}

     

       
788
       
-
       
	}

     

       
789
       
-
       


     

       
790
       
-
       
	// build result slice with only kept operations

     

       
791
       
-
       
	var result []LabelOp

     

       
792
       
-
       
	for i, op := range ops {

     

       
793
       
-
       
		if keep[i] {

     

       
794
       
-
       
			result = append(result, op)

     

       
795
       
-
       
		}

     

       
796
       
-
       
	}

     

       
797
       
-
       


     

       
798
       
-
       
	return result

     

       
799
       
-
       
}

     

       
800
       
-
       


     

       
801
       
-
       
func DefaultLabelDefs() []string {

     

       
802
       
-
       
	rkeys := []string{

     

       
803
       
-
       
		"wontfix",

     

       
804
       
-
       
		"duplicate",

     

       
805
       
-
       
		"assignee",

     

       
806
       
-
       
		"good-first-issue",

     

       
807
       
-
       
		"documentation",

     

       
808
       
-
       
	}

     

       
809
       
-
       


     

       
810
       
-
       
	defs := make([]string, len(rkeys))

     

       
811
       
-
       
	for i, r := range rkeys {

     

       
812
       
-
       
		defs[i] = fmt.Sprintf("at://%s/%s/%s", consts.TangledDid, tangled.LabelDefinitionNSID, r)

     

       
813
       
-
       
	}

     

       
814
       
-
       


     

       
815
       
-
       
	return defs

     

       
816
       
 
       
}

     

···

       
1
       
 
       
package db

     

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
0
       
 
       

     

       
4
       
 
       
	"database/sql"

     

       
0
       
 
       

     

       
0
       
 
       

     

       
5
       
 
       
	"fmt"

     

       
6
       
 
       
	"maps"

     

       
7
       
 
       
	"slices"

     
···

       
9
       
 
       
	"time"

     

       
10
       
 
       


     

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

     

       
12
       
+
       
	"tangled.org/core/appview/models"

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
13
       
 
       
)

     

       
14
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
15
       
 
       
// no updating type for now

     

       
16
       
+
       
func AddLabelDefinition(e Execer, l *models.LabelDefinition) (int64, error) {

     

       
17
       
 
       
	result, err := e.Exec(

     

       
18
       
 
       
		`insert into label_definitions (

     

       
19
       
 
       
			did,

     
···

       
59
       
 
       
	return id, nil

     

       
60
       
 
       
}

     

       
61
       
 
       


     

       
62
       
+
       
func DeleteLabelDefinition(e Execer, filters ...filter) error {

     

       
63
       
+
       
	var conditions []string

     

       
64
       
+
       
	var args []any

     

       
65
       
+
       
	for _, filter := range filters {

     

       
66
       
+
       
		conditions = append(conditions, filter.Condition())

     

       
67
       
+
       
		args = append(args, filter.Arg()...)

     

       
68
       
+
       
	}

     

       
69
       
+
       
	whereClause := ""

     

       
70
       
+
       
	if conditions != nil {

     

       
71
       
+
       
		whereClause = " where " + strings.Join(conditions, " and ")

     

       
72
       
+
       
	}

     

       
73
       
+
       
	query := fmt.Sprintf(`delete from label_definitions %s`, whereClause)

     

       
74
       
+
       
	_, err := e.Exec(query, args...)

     

       
75
       
+
       
	return err

     

       
76
       
+
       
}

     

       
77
       
+
       


     

       
78
       
+
       
func GetLabelDefinitions(e Execer, filters ...filter) ([]models.LabelDefinition, error) {

     

       
79
       
+
       
	var labelDefinitions []models.LabelDefinition

     

       
80
       
 
       
	var conditions []string

     

       
81
       
 
       
	var args []any

     

       
82
       
 
       


     
···

       
118
       
 
       
	defer rows.Close()

     

       
119
       
 
       


     

       
120
       
 
       
	for rows.Next() {

     

       
121
       
+
       
		var labelDefinition models.LabelDefinition

     

       
122
       
 
       
		var createdAt, enumVariants, scopes string

     

       
123
       
 
       
		var color sql.Null[string]

     

       
124
       
 
       
		var multiple int

     
···

       
167
       
 
       
}

     

       
168
       
 
       


     

       
169
       
 
       
// helper to get exactly one label def

     

       
170
       
+
       
func GetLabelDefinition(e Execer, filters ...filter) (*models.LabelDefinition, error) {

     

       
171
       
 
       
	labels, err := GetLabelDefinitions(e, filters...)

     

       
172
       
 
       
	if err != nil {

     

       
173
       
 
       
		return nil, err

     
···

       
184
       
 
       
	return &labels[0], nil

     

       
185
       
 
       
}

     

       
186
       
 
       


     

       
187
       
+
       
func AddLabelOp(e Execer, l *models.LabelOp) (int64, error) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
188
       
 
       
	now := time.Now()

     

       
189
       
 
       
	result, err := e.Exec(

     

       
190
       
 
       
		`insert into label_ops (

     
···

       
227
       
 
       
	return id, nil

     

       
228
       
 
       
}

     

       
229
       
 
       


     

       
230
       
+
       
func GetLabelOps(e Execer, filters ...filter) ([]models.LabelOp, error) {

     

       
231
       
+
       
	var labelOps []models.LabelOp

     

       
232
       
 
       
	var conditions []string

     

       
233
       
 
       
	var args []any

     

       
234
       
 
       


     
···

       
268
       
 
       
	defer rows.Close()

     

       
269
       
 
       


     

       
270
       
 
       
	for rows.Next() {

     

       
271
       
+
       
		var labelOp models.LabelOp

     

       
272
       
 
       
		var performedAt, indexedAt string

     

       
273
       
 
       


     

       
274
       
 
       
		if err := rows.Scan(

     
···

       
302
       
 
       
}

     

       
303
       
 
       


     

       
304
       
 
       
// get labels for a given list of subject URIs

     

       
305
       
+
       
func GetLabels(e Execer, filters ...filter) (map[syntax.ATURI]models.LabelState, error) {

     

       
306
       
 
       
	ops, err := GetLabelOps(e, filters...)

     

       
307
       
 
       
	if err != nil {

     

       
308
       
 
       
		return nil, err

     

       
309
       
 
       
	}

     

       
310
       
 
       


     

       
311
       
 
       
	// group ops by subject

     

       
312
       
+
       
	opsBySubject := make(map[syntax.ATURI][]models.LabelOp)

     

       
313
       
 
       
	for _, op := range ops {

     

       
314
       
 
       
		subject := syntax.ATURI(op.Subject)

     

       
315
       
 
       
		opsBySubject[subject] = append(opsBySubject[subject], op)

     
···

       
328
       
 
       
	}

     

       
329
       
 
       


     

       
330
       
 
       
	// apply label ops for each subject and collect results

     

       
331
       
+
       
	results := make(map[syntax.ATURI]models.LabelState)

     

       
332
       
 
       
	for subject, subjectOps := range opsBySubject {

     

       
333
       
+
       
		state := models.NewLabelState()

     

       
334
       
 
       
		actx.ApplyLabelOps(state, subjectOps)

     

       
335
       
 
       
		results[subject] = state

     

       
336
       
 
       
	}

     
···

       
338
       
 
       
	return results, nil

     

       
339
       
 
       
}

     

       
340
       
 
       


     

       
341
       
+
       
func NewLabelApplicationCtx(e Execer, filters ...filter) (*models.LabelApplicationCtx, error) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
342
       
 
       
	labels, err := GetLabelDefinitions(e, filters...)

     

       
343
       
 
       
	if err != nil {

     

       
344
       
 
       
		return nil, err

     

       
345
       
 
       
	}

     

       
346
       
 
       


     

       
347
       
+
       
	defs := make(map[string]*models.LabelDefinition)

     

       
348
       
 
       
	for _, l := range labels {

     

       
349
       
 
       
		defs[l.AtUri().String()] = &l

     

       
350
       
 
       
	}

     

       
351
       
 
       


     

       
352
       
+
       
	return &models.LabelApplicationCtx{defs}, nil

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
353
       
 
       
}

     

···

       
923
       
 
       
			return fmt.Errorf("invalid record: %w", err)

     

       
924
       
 
       
		}

     

       
925
       
 
       


     

       
926
       
-
       
		def, err := db.LabelDefinitionFromRecord(did, rkey, record)

     

       
927
       
 
       
		if err != nil {

     

       
928
       
 
       
			return fmt.Errorf("failed to parse labeldef from record: %w", err)

     

       
929
       
 
       
		}

     

···

       
923
       
 
       
			return fmt.Errorf("invalid record: %w", err)

     

       
924
       
 
       
		}

     

       
925
       
 
       


     

       
926
       
+
       
		def, err := models.LabelDefinitionFromRecord(did, rkey, record)

     

       
927
       
 
       
		if err != nil {

     

       
928
       
 
       
			return fmt.Errorf("failed to parse labeldef from record: %w", err)

     

       
929
       
 
       
		}

     

···

       
19
       
 
       
	"tangled.org/core/api/tangled"

     

       
20
       
 
       
	"tangled.org/core/appview/config"

     

       
21
       
 
       
	"tangled.org/core/appview/db"

     

       
0
       
 
       

     

       
22
       
 
       
	"tangled.org/core/appview/notify"

     

       
23
       
 
       
	"tangled.org/core/appview/oauth"

     

       
24
       
 
       
	"tangled.org/core/appview/pages"

     
···

       
103
       
 
       
		return

     

       
104
       
 
       
	}

     

       
105
       
 
       


     

       
106
       
-
       
	defs := make(map[string]*db.LabelDefinition)

     

       
107
       
 
       
	for _, l := range labelDefs {

     

       
108
       
 
       
		defs[l.AtUri().String()] = &l

     

       
109
       
 
       
	}

     
···

       
796
       
 
       
		return

     

       
797
       
 
       
	}

     

       
798
       
 
       


     

       
799
       
-
       
	defs := make(map[string]*db.LabelDefinition)

     

       
800
       
 
       
	for _, l := range labelDefs {

     

       
801
       
 
       
		defs[l.AtUri().String()] = &l

     

       
802
       
 
       
	}

     

···

       
19
       
 
       
	"tangled.org/core/api/tangled"

     

       
20
       
 
       
	"tangled.org/core/appview/config"

     

       
21
       
 
       
	"tangled.org/core/appview/db"

     

       
22
       
+
       
	"tangled.org/core/appview/models"

     

       
23
       
 
       
	"tangled.org/core/appview/notify"

     

       
24
       
 
       
	"tangled.org/core/appview/oauth"

     

       
25
       
 
       
	"tangled.org/core/appview/pages"

     
···

       
104
       
 
       
		return

     

       
105
       
 
       
	}

     

       
106
       
 
       


     

       
107
       
+
       
	defs := make(map[string]*models.LabelDefinition)

     

       
108
       
 
       
	for _, l := range labelDefs {

     

       
109
       
 
       
		defs[l.AtUri().String()] = &l

     

       
110
       
 
       
	}

     
···

       
797
       
 
       
		return

     

       
798
       
 
       
	}

     

       
799
       
 
       


     

       
800
       
+
       
	defs := make(map[string]*models.LabelDefinition)

     

       
801
       
 
       
	for _, l := range labelDefs {

     

       
802
       
 
       
		defs[l.AtUri().String()] = &l

     

       
803
       
 
       
	}

     

···

       
17
       
 
       
	"tangled.sh/tangled.sh/core/api/tangled"

     

       
18
       
 
       
	"tangled.sh/tangled.sh/core/appview/db"

     

       
19
       
 
       
	"tangled.sh/tangled.sh/core/appview/middleware"

     

       
0
       
 
       

     

       
20
       
 
       
	"tangled.sh/tangled.sh/core/appview/oauth"

     

       
21
       
 
       
	"tangled.sh/tangled.sh/core/appview/pages"

     

       
22
       
 
       
	"tangled.sh/tangled.sh/core/appview/validator"

     
···

       
113
       
 
       
		return

     

       
114
       
 
       
	}

     

       
115
       
 
       


     

       
116
       
-
       
	labelState := db.NewLabelState()

     

       
117
       
 
       
	actx.ApplyLabelOps(labelState, existingOps)

     

       
118
       
 
       


     

       
119
       
-
       
	var labelOps []db.LabelOp

     

       
120
       
 
       


     

       
121
       
 
       
	// first delete all existing state

     

       
122
       
 
       
	for key, vals := range labelState.Inner() {

     

       
123
       
 
       
		for val := range vals {

     

       
124
       
-
       
			labelOps = append(labelOps, db.LabelOp{

     

       
125
       
 
       
				Did:          did,

     

       
126
       
 
       
				Rkey:         rkey,

     

       
127
       
 
       
				Subject:      syntax.ATURI(subjectUri),

     

       
128
       
-
       
				Operation:    db.LabelOperationDel,

     

       
129
       
 
       
				OperandKey:   key,

     

       
130
       
 
       
				OperandValue: val,

     

       
131
       
 
       
				PerformedAt:  performedAt,

     
···

       
141
       
 
       
		}

     

       
142
       
 
       


     

       
143
       
 
       
		for _, val := range vals {

     

       
144
       
-
       
			labelOps = append(labelOps, db.LabelOp{

     

       
145
       
 
       
				Did:          did,

     

       
146
       
 
       
				Rkey:         rkey,

     

       
147
       
 
       
				Subject:      syntax.ATURI(subjectUri),

     

       
148
       
-
       
				Operation:    db.LabelOperationAdd,

     

       
149
       
 
       
				OperandKey:   key,

     

       
150
       
 
       
				OperandValue: val,

     

       
151
       
 
       
				PerformedAt:  performedAt,

     
···

       
155
       
 
       
	}

     

       
156
       
 
       


     

       
157
       
 
       
	// reduce the opset

     

       
158
       
-
       
	labelOps = db.ReduceLabelOps(labelOps)

     

       
159
       
 
       


     

       
160
       
 
       
	for i := range labelOps {

     

       
161
       
 
       
		def := actx.Defs[labelOps[i].OperandKey]

     
···

       
168
       
 
       
	// next, apply all ops introduced in this request and filter out ones that are no-ops

     

       
169
       
 
       
	validLabelOps := labelOps[:0]

     

       
170
       
 
       
	for _, op := range labelOps {

     

       
171
       
-
       
		if err = actx.ApplyLabelOp(labelState, op); err != db.LabelNoOpError {

     

       
172
       
 
       
			validLabelOps = append(validLabelOps, op)

     

       
173
       
 
       
		}

     

       
174
       
 
       
	}

     
···

       
180
       
 
       
	}

     

       
181
       
 
       


     

       
182
       
 
       
	// create an atproto record of valid ops

     

       
183
       
-
       
	record := db.LabelOpsAsRecord(validLabelOps)

     

       
184
       
 
       


     

       
185
       
 
       
	client, err := l.oauth.AuthorizedClient(r)

     

       
186
       
 
       
	if err != nil {

     

···

       
17
       
 
       
	"tangled.sh/tangled.sh/core/api/tangled"

     

       
18
       
 
       
	"tangled.sh/tangled.sh/core/appview/db"

     

       
19
       
 
       
	"tangled.sh/tangled.sh/core/appview/middleware"

     

       
20
       
+
       
	"tangled.sh/tangled.sh/core/appview/models"

     

       
21
       
 
       
	"tangled.sh/tangled.sh/core/appview/oauth"

     

       
22
       
 
       
	"tangled.sh/tangled.sh/core/appview/pages"

     

       
23
       
 
       
	"tangled.sh/tangled.sh/core/appview/validator"

     
···

       
114
       
 
       
		return

     

       
115
       
 
       
	}

     

       
116
       
 
       


     

       
117
       
+
       
	labelState := models.NewLabelState()

     

       
118
       
 
       
	actx.ApplyLabelOps(labelState, existingOps)

     

       
119
       
 
       


     

       
120
       
+
       
	var labelOps []models.LabelOp

     

       
121
       
 
       


     

       
122
       
 
       
	// first delete all existing state

     

       
123
       
 
       
	for key, vals := range labelState.Inner() {

     

       
124
       
 
       
		for val := range vals {

     

       
125
       
+
       
			labelOps = append(labelOps, models.LabelOp{

     

       
126
       
 
       
				Did:          did,

     

       
127
       
 
       
				Rkey:         rkey,

     

       
128
       
 
       
				Subject:      syntax.ATURI(subjectUri),

     

       
129
       
+
       
				Operation:    models.LabelOperationDel,

     

       
130
       
 
       
				OperandKey:   key,

     

       
131
       
 
       
				OperandValue: val,

     

       
132
       
 
       
				PerformedAt:  performedAt,

     
···

       
142
       
 
       
		}

     

       
143
       
 
       


     

       
144
       
 
       
		for _, val := range vals {

     

       
145
       
+
       
			labelOps = append(labelOps, models.LabelOp{

     

       
146
       
 
       
				Did:          did,

     

       
147
       
 
       
				Rkey:         rkey,

     

       
148
       
 
       
				Subject:      syntax.ATURI(subjectUri),

     

       
149
       
+
       
				Operation:    models.LabelOperationAdd,

     

       
150
       
 
       
				OperandKey:   key,

     

       
151
       
 
       
				OperandValue: val,

     

       
152
       
 
       
				PerformedAt:  performedAt,

     
···

       
156
       
 
       
	}

     

       
157
       
 
       


     

       
158
       
 
       
	// reduce the opset

     

       
159
       
+
       
	labelOps = models.ReduceLabelOps(labelOps)

     

       
160
       
 
       


     

       
161
       
 
       
	for i := range labelOps {

     

       
162
       
 
       
		def := actx.Defs[labelOps[i].OperandKey]

     
···

       
169
       
 
       
	// next, apply all ops introduced in this request and filter out ones that are no-ops

     

       
170
       
 
       
	validLabelOps := labelOps[:0]

     

       
171
       
 
       
	for _, op := range labelOps {

     

       
172
       
+
       
		if err = actx.ApplyLabelOp(labelState, op); err != models.LabelNoOpError {

     

       
173
       
 
       
			validLabelOps = append(validLabelOps, op)

     

       
174
       
 
       
		}

     

       
175
       
 
       
	}

     
···

       
181
       
 
       
	}

     

       
182
       
 
       


     

       
183
       
 
       
	// create an atproto record of valid ops

     

       
184
       
+
       
	record := models.LabelOpsAsRecord(validLabelOps)

     

       
185
       
 
       


     

       
186
       
 
       
	client, err := l.oauth.AuthorizedClient(r)

     

       
187
       
 
       
	if err != nil {

     

···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0