appview: improve the logging situation a bit #654

···

       
4
       
 
       
	"context"

     

       
5
       
 
       
	"database/sql"

     

       
6
       
 
       
	"fmt"

     

       
7
       
-
       
	"log"

     

       
8
       
 
       
	"reflect"

     

       
9
       
 
       
	"strings"

     

       
10
       
 
       


     

       
11
       
 
       
	_ "github.com/mattn/go-sqlite3"

     

       
0
       
 
       

     

       
12
       
 
       
)

     

       
13
       
 
       


     

       
14
       
 
       
type DB struct {

     

       
15
       
 
       
	*sql.DB

     

       
0
       
 
       

     

       
16
       
 
       
}

     

       
17
       
 
       


     

       
18
       
 
       
type Execer interface {

     
···

       
26
       
 
       
	PrepareContext(ctx context.Context, query string) (*sql.Stmt, error)

     

       
27
       
 
       
}

     

       
28
       
 
       


     

       
29
       
-
       
func Make(dbPath string) (*DB, error) {

     

       
30
       
 
       
	// https://github.com/mattn/go-sqlite3#connection-string

     

       
31
       
 
       
	opts := []string{

     

       
32
       
 
       
		"_foreign_keys=1",

     
···

       
35
       
 
       
		"_auto_vacuum=incremental",

     

       
36
       
 
       
	}

     

       
37
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
38
       
 
       
	db, err := sql.Open("sqlite3", dbPath+"?"+strings.Join(opts, "&"))

     

       
39
       
 
       
	if err != nil {

     

       
40
       
 
       
		return nil, err

     

       
41
       
 
       
	}

     

       
42
       
 
       


     

       
43
       
-
       
	ctx := context.Background()

     

       
44
       
-
       


     

       
45
       
 
       
	conn, err := db.Conn(ctx)

     

       
46
       
 
       
	if err != nil {

     

       
47
       
 
       
		return nil, err

     
···

       
574
       
 
       
	}

     

       
575
       
 
       


     

       
576
       
 
       
	// run migrations

     

       
577
       
-
       
	runMigration(conn, "add-description-to-repos", func(tx *sql.Tx) error {

     

       
578
       
 
       
		tx.Exec(`

     

       
579
       
 
       
			alter table repos add column description text check (length(description) <= 200);

     

       
580
       
 
       
		`)

     

       
581
       
 
       
		return nil

     

       
582
       
 
       
	})

     

       
583
       
 
       


     

       
584
       
-
       
	runMigration(conn, "add-rkey-to-pubkeys", func(tx *sql.Tx) error {

     

       
585
       
 
       
		// add unconstrained column

     

       
586
       
 
       
		_, err := tx.Exec(`

     

       
587
       
 
       
			alter table public_keys

     
···

       
604
       
 
       
		return nil

     

       
605
       
 
       
	})

     

       
606
       
 
       


     

       
607
       
-
       
	runMigration(conn, "add-rkey-to-comments", func(tx *sql.Tx) error {

     

       
608
       
 
       
		_, err := tx.Exec(`

     

       
609
       
 
       
			alter table comments drop column comment_at;

     

       
610
       
 
       
			alter table comments add column rkey text;

     
···

       
612
       
 
       
		return err

     

       
613
       
 
       
	})

     

       
614
       
 
       


     

       
615
       
-
       
	runMigration(conn, "add-deleted-and-edited-to-issue-comments", func(tx *sql.Tx) error {

     

       
616
       
 
       
		_, err := tx.Exec(`

     

       
617
       
 
       
			alter table comments add column deleted text; -- timestamp

     

       
618
       
 
       
			alter table comments add column edited text; -- timestamp

     
···

       
620
       
 
       
		return err

     

       
621
       
 
       
	})

     

       
622
       
 
       


     

       
623
       
-
       
	runMigration(conn, "add-source-info-to-pulls-and-submissions", func(tx *sql.Tx) error {

     

       
624
       
 
       
		_, err := tx.Exec(`

     

       
625
       
 
       
			alter table pulls add column source_branch text;

     

       
626
       
 
       
			alter table pulls add column source_repo_at text;

     
···

       
629
       
 
       
		return err

     

       
630
       
 
       
	})

     

       
631
       
 
       


     

       
632
       
-
       
	runMigration(conn, "add-source-to-repos", func(tx *sql.Tx) error {

     

       
633
       
 
       
		_, err := tx.Exec(`

     

       
634
       
 
       
			alter table repos add column source text;

     

       
635
       
 
       
		`)

     
···

       
641
       
 
       
	//

     

       
642
       
 
       
	// [0]: https://sqlite.org/pragma.html#pragma_foreign_keys

     

       
643
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       
644
       
-
       
	runMigration(conn, "recreate-pulls-column-for-stacking-support", func(tx *sql.Tx) error {

     

       
645
       
 
       
		_, err := tx.Exec(`

     

       
646
       
 
       
			create table pulls_new (

     

       
647
       
 
       
				-- identifiers

     
···

       
698
       
 
       
	})

     

       
699
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = on;")

     

       
700
       
 
       


     

       
701
       
-
       
	runMigration(conn, "add-spindle-to-repos", func(tx *sql.Tx) error {

     

       
702
       
 
       
		tx.Exec(`

     

       
703
       
 
       
			alter table repos add column spindle text;

     

       
704
       
 
       
		`)

     
···

       
708
       
 
       
	// drop all knot secrets, add unique constraint to knots

     

       
709
       
 
       
	//

     

       
710
       
 
       
	// knots will henceforth use service auth for signed requests

     

       
711
       
-
       
	runMigration(conn, "no-more-secrets", func(tx *sql.Tx) error {

     

       
712
       
 
       
		_, err := tx.Exec(`

     

       
713
       
 
       
			create table registrations_new (

     

       
714
       
 
       
				id integer primary key autoincrement,

     
···

       
731
       
 
       
	})

     

       
732
       
 
       


     

       
733
       
 
       
	// recreate and add rkey + created columns with default constraint

     

       
734
       
-
       
	runMigration(conn, "rework-collaborators-table", func(tx *sql.Tx) error {

     

       
735
       
 
       
		// create new table

     

       
736
       
 
       
		// - repo_at instead of repo integer

     

       
737
       
 
       
		// - rkey field

     
···

       
785
       
 
       
		return err

     

       
786
       
 
       
	})

     

       
787
       
 
       


     

       
788
       
-
       
	runMigration(conn, "add-rkey-to-issues", func(tx *sql.Tx) error {

     

       
789
       
 
       
		_, err := tx.Exec(`

     

       
790
       
 
       
			alter table issues add column rkey text not null default '';

     

       
791
       
 
       


     
···

       
797
       
 
       
	})

     

       
798
       
 
       


     

       
799
       
 
       
	// repurpose the read-only column to "needs-upgrade"

     

       
800
       
-
       
	runMigration(conn, "rename-registrations-read-only-to-needs-upgrade", func(tx *sql.Tx) error {

     

       
801
       
 
       
		_, err := tx.Exec(`

     

       
802
       
 
       
			alter table registrations rename column read_only to needs_upgrade;

     

       
803
       
 
       
		`)

     
···

       
805
       
 
       
	})

     

       
806
       
 
       


     

       
807
       
 
       
	// require all knots to upgrade after the release of total xrpc

     

       
808
       
-
       
	runMigration(conn, "migrate-knots-to-total-xrpc", func(tx *sql.Tx) error {

     

       
809
       
 
       
		_, err := tx.Exec(`

     

       
810
       
 
       
			update registrations set needs_upgrade = 1;

     

       
811
       
 
       
		`)

     
···

       
813
       
 
       
	})

     

       
814
       
 
       


     

       
815
       
 
       
	// require all knots to upgrade after the release of total xrpc

     

       
816
       
-
       
	runMigration(conn, "migrate-spindles-to-xrpc-owner", func(tx *sql.Tx) error {

     

       
817
       
 
       
		_, err := tx.Exec(`

     

       
818
       
 
       
			alter table spindles add column needs_upgrade integer not null default 0;

     

       
819
       
 
       
		`)

     
···

       
831
       
 
       
	//

     

       
832
       
 
       
	// disable foreign-keys for the next migration

     

       
833
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       
834
       
-
       
	runMigration(conn, "remove-issue-at-from-issues", func(tx *sql.Tx) error {

     

       
835
       
 
       
		_, err := tx.Exec(`

     

       
836
       
 
       
			create table if not exists issues_new (

     

       
837
       
 
       
				-- identifiers

     
···

       
901
       
 
       
	// - new columns

     

       
902
       
 
       
	//   * column "reply_to" which can be any other comment

     

       
903
       
 
       
	//   * column "at-uri" which is a generated column

     

       
904
       
-
       
	runMigration(conn, "rework-issue-comments", func(tx *sql.Tx) error {

     

       
905
       
 
       
		_, err := tx.Exec(`

     

       
906
       
 
       
			create table if not exists issue_comments (

     

       
907
       
 
       
				-- identifiers

     
···

       
961
       
 
       
	//

     

       
962
       
 
       
	// disable foreign-keys for the next migration

     

       
963
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       
964
       
-
       
	runMigration(conn, "add-at-uri-to-pulls", func(tx *sql.Tx) error {

     

       
965
       
 
       
		_, err := tx.Exec(`

     

       
966
       
 
       
		create table if not exists pulls_new (

     

       
967
       
 
       
			-- identifiers

     
···

       
1042
       
 
       
	//

     

       
1043
       
 
       
	// disable foreign-keys for the next migration

     

       
1044
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       
1045
       
-
       
	runMigration(conn, "remove-repo-at-pull-id-from-pull-submissions", func(tx *sql.Tx) error {

     

       
1046
       
 
       
		_, err := tx.Exec(`

     

       
1047
       
 
       
		create table if not exists pull_submissions_new (

     

       
1048
       
 
       
			-- identifiers

     
···

       
1094
       
 
       
	})

     

       
1095
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = on;")

     

       
1096
       
 
       


     

       
1097
       
-
       
	return &DB{db}, nil

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1098
       
 
       
}

     

       
1099
       
 
       


     

       
1100
       
 
       
type migrationFn = func(*sql.Tx) error

     

       
1101
       
 
       


     

       
1102
       
-
       
func runMigration(c *sql.Conn, name string, migrationFn migrationFn) error {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1103
       
 
       
	tx, err := c.BeginTx(context.Background(), nil)

     

       
1104
       
 
       
	if err != nil {

     

       
1105
       
 
       
		return err

     
···

       
1116
       
 
       
		// run migration

     

       
1117
       
 
       
		err = migrationFn(tx)

     

       
1118
       
 
       
		if err != nil {

     

       
1119
       
-
       
			log.Printf("Failed to run migration %s: %v", name, err)

     

       
1120
       
 
       
			return err

     

       
1121
       
 
       
		}

     

       
1122
       
 
       


     

       
1123
       
 
       
		// mark migration as complete

     

       
1124
       
 
       
		_, err = tx.Exec("insert into migrations (name) values (?)", name)

     

       
1125
       
 
       
		if err != nil {

     

       
1126
       
-
       
			log.Printf("Failed to mark migration %s as complete: %v", name, err)

     

       
1127
       
 
       
			return err

     

       
1128
       
 
       
		}

     

       
1129
       
 
       


     
···

       
1132
       
 
       
			return err

     

       
1133
       
 
       
		}

     

       
1134
       
 
       


     

       
1135
       
-
       
		log.Printf("migration %s applied successfully", name)

     

       
1136
       
 
       
	} else {

     

       
1137
       
-
       
		log.Printf("skipped migration %s, already applied", name)

     

       
1138
       
 
       
	}

     

       
1139
       
 
       


     

       
1140
       
 
       
	return nil

     

···

       
4
       
 
       
	"context"

     

       
5
       
 
       
	"database/sql"

     

       
6
       
 
       
	"fmt"

     

       
7
       
+
       
	"log/slog"

     

       
8
       
 
       
	"reflect"

     

       
9
       
 
       
	"strings"

     

       
10
       
 
       


     

       
11
       
 
       
	_ "github.com/mattn/go-sqlite3"

     

       
12
       
+
       
	"tangled.org/core/log"

     

       
13
       
 
       
)

     

       
14
       
 
       


     

       
15
       
 
       
type DB struct {

     

       
16
       
 
       
	*sql.DB

     

       
17
       
+
       
	logger *slog.Logger

     

       
18
       
 
       
}

     

       
19
       
 
       


     

       
20
       
 
       
type Execer interface {

     
···

       
28
       
 
       
	PrepareContext(ctx context.Context, query string) (*sql.Stmt, error)

     

       
29
       
 
       
}

     

       
30
       
 
       


     

       
31
       
+
       
func Make(ctx context.Context, dbPath string) (*DB, error) {

     

       
32
       
 
       
	// https://github.com/mattn/go-sqlite3#connection-string

     

       
33
       
 
       
	opts := []string{

     

       
34
       
 
       
		"_foreign_keys=1",

     
···

       
37
       
 
       
		"_auto_vacuum=incremental",

     

       
38
       
 
       
	}

     

       
39
       
 
       


     

       
40
       
+
       
	logger := log.FromContext(ctx)

     

       
41
       
+
       
	logger = log.SubLogger(logger, "db")

     

       
42
       
+
       


     

       
43
       
 
       
	db, err := sql.Open("sqlite3", dbPath+"?"+strings.Join(opts, "&"))

     

       
44
       
 
       
	if err != nil {

     

       
45
       
 
       
		return nil, err

     

       
46
       
 
       
	}

     

       
47
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
48
       
 
       
	conn, err := db.Conn(ctx)

     

       
49
       
 
       
	if err != nil {

     

       
50
       
 
       
		return nil, err

     
···

       
577
       
 
       
	}

     

       
578
       
 
       


     

       
579
       
 
       
	// run migrations

     

       
580
       
+
       
	runMigration(conn, logger, "add-description-to-repos", func(tx *sql.Tx) error {

     

       
581
       
 
       
		tx.Exec(`

     

       
582
       
 
       
			alter table repos add column description text check (length(description) <= 200);

     

       
583
       
 
       
		`)

     

       
584
       
 
       
		return nil

     

       
585
       
 
       
	})

     

       
586
       
 
       


     

       
587
       
+
       
	runMigration(conn, logger, "add-rkey-to-pubkeys", func(tx *sql.Tx) error {

     

       
588
       
 
       
		// add unconstrained column

     

       
589
       
 
       
		_, err := tx.Exec(`

     

       
590
       
 
       
			alter table public_keys

     
···

       
607
       
 
       
		return nil

     

       
608
       
 
       
	})

     

       
609
       
 
       


     

       
610
       
+
       
	runMigration(conn, logger, "add-rkey-to-comments", func(tx *sql.Tx) error {

     

       
611
       
 
       
		_, err := tx.Exec(`

     

       
612
       
 
       
			alter table comments drop column comment_at;

     

       
613
       
 
       
			alter table comments add column rkey text;

     
···

       
615
       
 
       
		return err

     

       
616
       
 
       
	})

     

       
617
       
 
       


     

       
618
       
+
       
	runMigration(conn, logger, "add-deleted-and-edited-to-issue-comments", func(tx *sql.Tx) error {

     

       
619
       
 
       
		_, err := tx.Exec(`

     

       
620
       
 
       
			alter table comments add column deleted text; -- timestamp

     

       
621
       
 
       
			alter table comments add column edited text; -- timestamp

     
···

       
623
       
 
       
		return err

     

       
624
       
 
       
	})

     

       
625
       
 
       


     

       
626
       
+
       
	runMigration(conn, logger, "add-source-info-to-pulls-and-submissions", func(tx *sql.Tx) error {

     

       
627
       
 
       
		_, err := tx.Exec(`

     

       
628
       
 
       
			alter table pulls add column source_branch text;

     

       
629
       
 
       
			alter table pulls add column source_repo_at text;

     
···

       
632
       
 
       
		return err

     

       
633
       
 
       
	})

     

       
634
       
 
       


     

       
635
       
+
       
	runMigration(conn, logger, "add-source-to-repos", func(tx *sql.Tx) error {

     

       
636
       
 
       
		_, err := tx.Exec(`

     

       
637
       
 
       
			alter table repos add column source text;

     

       
638
       
 
       
		`)

     
···

       
644
       
 
       
	//

     

       
645
       
 
       
	// [0]: https://sqlite.org/pragma.html#pragma_foreign_keys

     

       
646
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       
647
       
+
       
	runMigration(conn, logger, "recreate-pulls-column-for-stacking-support", func(tx *sql.Tx) error {

     

       
648
       
 
       
		_, err := tx.Exec(`

     

       
649
       
 
       
			create table pulls_new (

     

       
650
       
 
       
				-- identifiers

     
···

       
701
       
 
       
	})

     

       
702
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = on;")

     

       
703
       
 
       


     

       
704
       
+
       
	runMigration(conn, logger, "add-spindle-to-repos", func(tx *sql.Tx) error {

     

       
705
       
 
       
		tx.Exec(`

     

       
706
       
 
       
			alter table repos add column spindle text;

     

       
707
       
 
       
		`)

     
···

       
711
       
 
       
	// drop all knot secrets, add unique constraint to knots

     

       
712
       
 
       
	//

     

       
713
       
 
       
	// knots will henceforth use service auth for signed requests

     

       
714
       
+
       
	runMigration(conn, logger, "no-more-secrets", func(tx *sql.Tx) error {

     

       
715
       
 
       
		_, err := tx.Exec(`

     

       
716
       
 
       
			create table registrations_new (

     

       
717
       
 
       
				id integer primary key autoincrement,

     
···

       
734
       
 
       
	})

     

       
735
       
 
       


     

       
736
       
 
       
	// recreate and add rkey + created columns with default constraint

     

       
737
       
+
       
	runMigration(conn, logger, "rework-collaborators-table", func(tx *sql.Tx) error {

     

       
738
       
 
       
		// create new table

     

       
739
       
 
       
		// - repo_at instead of repo integer

     

       
740
       
 
       
		// - rkey field

     
···

       
788
       
 
       
		return err

     

       
789
       
 
       
	})

     

       
790
       
 
       


     

       
791
       
+
       
	runMigration(conn, logger, "add-rkey-to-issues", func(tx *sql.Tx) error {

     

       
792
       
 
       
		_, err := tx.Exec(`

     

       
793
       
 
       
			alter table issues add column rkey text not null default '';

     

       
794
       
 
       


     
···

       
800
       
 
       
	})

     

       
801
       
 
       


     

       
802
       
 
       
	// repurpose the read-only column to "needs-upgrade"

     

       
803
       
+
       
	runMigration(conn, logger, "rename-registrations-read-only-to-needs-upgrade", func(tx *sql.Tx) error {

     

       
804
       
 
       
		_, err := tx.Exec(`

     

       
805
       
 
       
			alter table registrations rename column read_only to needs_upgrade;

     

       
806
       
 
       
		`)

     
···

       
808
       
 
       
	})

     

       
809
       
 
       


     

       
810
       
 
       
	// require all knots to upgrade after the release of total xrpc

     

       
811
       
+
       
	runMigration(conn, logger, "migrate-knots-to-total-xrpc", func(tx *sql.Tx) error {

     

       
812
       
 
       
		_, err := tx.Exec(`

     

       
813
       
 
       
			update registrations set needs_upgrade = 1;

     

       
814
       
 
       
		`)

     
···

       
816
       
 
       
	})

     

       
817
       
 
       


     

       
818
       
 
       
	// require all knots to upgrade after the release of total xrpc

     

       
819
       
+
       
	runMigration(conn, logger, "migrate-spindles-to-xrpc-owner", func(tx *sql.Tx) error {

     

       
820
       
 
       
		_, err := tx.Exec(`

     

       
821
       
 
       
			alter table spindles add column needs_upgrade integer not null default 0;

     

       
822
       
 
       
		`)

     
···

       
834
       
 
       
	//

     

       
835
       
 
       
	// disable foreign-keys for the next migration

     

       
836
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       
837
       
+
       
	runMigration(conn, logger, "remove-issue-at-from-issues", func(tx *sql.Tx) error {

     

       
838
       
 
       
		_, err := tx.Exec(`

     

       
839
       
 
       
			create table if not exists issues_new (

     

       
840
       
 
       
				-- identifiers

     
···

       
904
       
 
       
	// - new columns

     

       
905
       
 
       
	//   * column "reply_to" which can be any other comment

     

       
906
       
 
       
	//   * column "at-uri" which is a generated column

     

       
907
       
+
       
	runMigration(conn, logger, "rework-issue-comments", func(tx *sql.Tx) error {

     

       
908
       
 
       
		_, err := tx.Exec(`

     

       
909
       
 
       
			create table if not exists issue_comments (

     

       
910
       
 
       
				-- identifiers

     
···

       
964
       
 
       
	//

     

       
965
       
 
       
	// disable foreign-keys for the next migration

     

       
966
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       
967
       
+
       
	runMigration(conn, logger, "add-at-uri-to-pulls", func(tx *sql.Tx) error {

     

       
968
       
 
       
		_, err := tx.Exec(`

     

       
969
       
 
       
		create table if not exists pulls_new (

     

       
970
       
 
       
			-- identifiers

     
···

       
1045
       
 
       
	//

     

       
1046
       
 
       
	// disable foreign-keys for the next migration

     

       
1047
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = off;")

     

       
1048
       
+
       
	runMigration(conn, logger, "remove-repo-at-pull-id-from-pull-submissions", func(tx *sql.Tx) error {

     

       
1049
       
 
       
		_, err := tx.Exec(`

     

       
1050
       
 
       
		create table if not exists pull_submissions_new (

     

       
1051
       
 
       
			-- identifiers

     
···

       
1097
       
 
       
	})

     

       
1098
       
 
       
	conn.ExecContext(ctx, "pragma foreign_keys = on;")

     

       
1099
       
 
       


     

       
1100
       
+
       
	return &DB{

     

       
1101
       
+
       
		db,

     

       
1102
       
+
       
		logger,

     

       
1103
       
+
       
	}, nil

     

       
1104
       
 
       
}

     

       
1105
       
 
       


     

       
1106
       
 
       
type migrationFn = func(*sql.Tx) error

     

       
1107
       
 
       


     

       
1108
       
+
       
func runMigration(c *sql.Conn, logger *slog.Logger, name string, migrationFn migrationFn) error {

     

       
1109
       
+
       
	logger = logger.With("migration", name)

     

       
1110
       
+
       


     

       
1111
       
 
       
	tx, err := c.BeginTx(context.Background(), nil)

     

       
1112
       
 
       
	if err != nil {

     

       
1113
       
 
       
		return err

     
···

       
1124
       
 
       
		// run migration

     

       
1125
       
 
       
		err = migrationFn(tx)

     

       
1126
       
 
       
		if err != nil {

     

       
1127
       
+
       
			logger.Error("failed to run migration", "err", err)

     

       
1128
       
 
       
			return err

     

       
1129
       
 
       
		}

     

       
1130
       
 
       


     

       
1131
       
 
       
		// mark migration as complete

     

       
1132
       
 
       
		_, err = tx.Exec("insert into migrations (name) values (?)", name)

     

       
1133
       
 
       
		if err != nil {

     

       
1134
       
+
       
			logger.Error("failed to mark migration as complete", "err", err)

     

       
1135
       
 
       
			return err

     

       
1136
       
 
       
		}

     

       
1137
       
 
       


     
···

       
1140
       
 
       
			return err

     

       
1141
       
 
       
		}

     

       
1142
       
 
       


     

       
1143
       
+
       
		logger.Info("migration applied successfully")

     

       
1144
       
 
       
	} else {

     

       
1145
       
+
       
		logger.Warn("skipped migration, already applied")

     

       
1146
       
 
       
	}

     

       
1147
       
 
       


     

       
1148
       
 
       
	return nil

     

···

       
89
       
 
       
		}

     

       
90
       
 
       


     

       
91
       
 
       
		if err != nil {

     

       
92
       
-
       
			l.Debug("error ingesting record", "err", err)

     

       
93
       
 
       
		}

     

       
94
       
 
       


     

       
95
       
 
       
		return nil

     

···

       
89
       
 
       
		}

     

       
90
       
 
       


     

       
91
       
 
       
		if err != nil {

     

       
92
       
+
       
			l.Warn("refused to ingest record", "err", err)

     

       
93
       
 
       
		}

     

       
94
       
 
       


     

       
95
       
 
       
		return nil

     

···

       
5
       
 
       
	"database/sql"

     

       
6
       
 
       
	"errors"

     

       
7
       
 
       
	"fmt"

     

       
8
       
-
       
	"log"

     

       
9
       
 
       
	"log/slog"

     

       
10
       
 
       
	"net/http"

     

       
11
       
 
       
	"slices"

     
···

       
28
       
 
       
	"tangled.org/core/appview/reporesolver"

     

       
29
       
 
       
	"tangled.org/core/appview/validator"

     

       
30
       
 
       
	"tangled.org/core/idresolver"

     

       
31
       
-
       
	tlog "tangled.org/core/log"

     

       
32
       
 
       
	"tangled.org/core/tid"

     

       
33
       
 
       
)

     

       
34
       
 
       


     
···

       
53
       
 
       
	config *config.Config,

     

       
54
       
 
       
	notifier notify.Notifier,

     

       
55
       
 
       
	validator *validator.Validator,

     

       
0
       
 
       

     

       
56
       
 
       
) *Issues {

     

       
57
       
 
       
	return &Issues{

     

       
58
       
 
       
		oauth:        oauth,

     
···

       
62
       
 
       
		db:           db,

     

       
63
       
 
       
		config:       config,

     

       
64
       
 
       
		notifier:     notifier,

     

       
65
       
-
       
		logger:       tlog.New("issues"),

     

       
66
       
 
       
		validator:    validator,

     

       
67
       
 
       
	}

     

       
68
       
 
       
}

     
···

       
72
       
 
       
	user := rp.oauth.GetUser(r)

     

       
73
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
74
       
 
       
	if err != nil {

     

       
75
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
76
       
 
       
		return

     

       
77
       
 
       
	}

     

       
78
       
 
       


     
···

       
99
       
 
       
		db.FilterContains("scope", tangled.RepoIssueNSID),

     

       
100
       
 
       
	)

     

       
101
       
 
       
	if err != nil {

     

       
102
       
-
       
		log.Println("failed to fetch labels", err)

     

       
103
       
 
       
		rp.pages.Error503(w)

     

       
104
       
 
       
		return

     

       
105
       
 
       
	}

     
···

       
126
       
 
       
	user := rp.oauth.GetUser(r)

     

       
127
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
128
       
 
       
	if err != nil {

     

       
129
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
130
       
 
       
		return

     

       
131
       
 
       
	}

     

       
132
       
 
       


     
···

       
199
       
 
       


     

       
200
       
 
       
		err = db.PutIssue(tx, newIssue)

     

       
201
       
 
       
		if err != nil {

     

       
202
       
-
       
			log.Println("failed to edit issue", err)

     

       
203
       
 
       
			rp.pages.Notice(w, "issues", "Failed to edit issue.")

     

       
204
       
 
       
			return

     

       
205
       
 
       
		}

     
···

       
237
       
 
       
	// delete from PDS

     

       
238
       
 
       
	client, err := rp.oauth.AuthorizedClient(r)

     

       
239
       
 
       
	if err != nil {

     

       
240
       
-
       
		log.Println("failed to get authorized client", err)

     

       
241
       
 
       
		rp.pages.Notice(w, "issue-comment", "Failed to delete comment.")

     

       
242
       
 
       
		return

     

       
243
       
 
       
	}

     
···

       
282
       
 
       


     

       
283
       
 
       
	collaborators, err := f.Collaborators(r.Context())

     

       
284
       
 
       
	if err != nil {

     

       
285
       
-
       
		log.Println("failed to fetch repo collaborators: %w", err)

     

       
286
       
 
       
	}

     

       
287
       
 
       
	isCollaborator := slices.ContainsFunc(collaborators, func(collab pages.Collaborator) bool {

     

       
288
       
 
       
		return user.Did == collab.Did

     
···

       
296
       
 
       
			db.FilterEq("id", issue.Id),

     

       
297
       
 
       
		)

     

       
298
       
 
       
		if err != nil {

     

       
299
       
-
       
			log.Println("failed to close issue", err)

     

       
300
       
 
       
			rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")

     

       
301
       
 
       
			return

     

       
302
       
 
       
		}

     
···

       
307
       
 
       
		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId))

     

       
308
       
 
       
		return

     

       
309
       
 
       
	} else {

     

       
310
       
-
       
		log.Println("user is not permitted to close issue")

     

       
311
       
 
       
		http.Error(w, "for biden", http.StatusUnauthorized)

     

       
312
       
 
       
		return

     

       
313
       
 
       
	}

     
···

       
318
       
 
       
	user := rp.oauth.GetUser(r)

     

       
319
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
320
       
 
       
	if err != nil {

     

       
321
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
322
       
 
       
		return

     

       
323
       
 
       
	}

     

       
324
       
 
       


     
···

       
331
       
 
       


     

       
332
       
 
       
	collaborators, err := f.Collaborators(r.Context())

     

       
333
       
 
       
	if err != nil {

     

       
334
       
-
       
		log.Println("failed to fetch repo collaborators: %w", err)

     

       
335
       
 
       
	}

     

       
336
       
 
       
	isCollaborator := slices.ContainsFunc(collaborators, func(collab pages.Collaborator) bool {

     

       
337
       
 
       
		return user.Did == collab.Did

     
···

       
344
       
 
       
			db.FilterEq("id", issue.Id),

     

       
345
       
 
       
		)

     

       
346
       
 
       
		if err != nil {

     

       
347
       
-
       
			log.Println("failed to reopen issue", err)

     

       
348
       
 
       
			rp.pages.Notice(w, "issue-action", "Failed to reopen issue. Try again later.")

     

       
349
       
 
       
			return

     

       
350
       
 
       
		}

     

       
351
       
 
       
		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId))

     

       
352
       
 
       
		return

     

       
353
       
 
       
	} else {

     

       
354
       
-
       
		log.Println("user is not the owner of the repo")

     

       
355
       
 
       
		http.Error(w, "forbidden", http.StatusUnauthorized)

     

       
356
       
 
       
		return

     

       
357
       
 
       
	}

     
···

       
538
       
 
       
		newBody := r.FormValue("body")

     

       
539
       
 
       
		client, err := rp.oauth.AuthorizedClient(r)

     

       
540
       
 
       
		if err != nil {

     

       
541
       
-
       
			log.Println("failed to get authorized client", err)

     

       
542
       
 
       
			rp.pages.Notice(w, "issue-comment", "Failed to create comment.")

     

       
543
       
 
       
			return

     

       
544
       
 
       
		}

     
···

       
551
       
 
       


     

       
552
       
 
       
		_, err = db.AddIssueComment(rp.db, newComment)

     

       
553
       
 
       
		if err != nil {

     

       
554
       
-
       
			log.Println("failed to perferom update-description query", err)

     

       
555
       
 
       
			rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.")

     

       
556
       
 
       
			return

     

       
557
       
 
       
		}

     
···

       
561
       
 
       
			// update the record on pds

     

       
562
       
 
       
			ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoIssueCommentNSID, user.Did, comment.Rkey)

     

       
563
       
 
       
			if err != nil {

     

       
564
       
-
       
				log.Println("failed to get record", "err", err, "did", newComment.Did, "rkey", newComment.Rkey)

     

       
565
       
 
       
				rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "Failed to update description, no record found on PDS.")

     

       
566
       
 
       
				return

     

       
567
       
 
       
			}

     
···

       
729
       
 
       
	if comment.Rkey != "" {

     

       
730
       
 
       
		client, err := rp.oauth.AuthorizedClient(r)

     

       
731
       
 
       
		if err != nil {

     

       
732
       
-
       
			log.Println("failed to get authorized client", err)

     

       
733
       
 
       
			rp.pages.Notice(w, "issue-comment", "Failed to delete comment.")

     

       
734
       
 
       
			return

     

       
735
       
 
       
		}

     
···

       
739
       
 
       
			Rkey:       comment.Rkey,

     

       
740
       
 
       
		})

     

       
741
       
 
       
		if err != nil {

     

       
742
       
-
       
			log.Println(err)

     

       
743
       
 
       
		}

     

       
744
       
 
       
	}

     

       
745
       
 
       


     
···

       
757
       
 
       
}

     

       
758
       
 
       


     

       
759
       
 
       
func (rp *Issues) RepoIssues(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
760
       
 
       
	params := r.URL.Query()

     

       
761
       
 
       
	state := params.Get("state")

     

       
762
       
 
       
	isOpen := true

     
···

       
771
       
 
       


     

       
772
       
 
       
	page, ok := r.Context().Value("page").(pagination.Page)

     

       
773
       
 
       
	if !ok {

     

       
774
       
-
       
		log.Println("failed to get page")

     

       
775
       
 
       
		page = pagination.FirstPage()

     

       
776
       
 
       
	}

     

       
777
       
 
       


     

       
778
       
 
       
	user := rp.oauth.GetUser(r)

     

       
779
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
780
       
 
       
	if err != nil {

     

       
781
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
782
       
 
       
		return

     

       
783
       
 
       
	}

     

       
784
       
 
       


     
···

       
793
       
 
       
		db.FilterEq("open", openVal),

     

       
794
       
 
       
	)

     

       
795
       
 
       
	if err != nil {

     

       
796
       
-
       
		log.Println("failed to get issues", err)

     

       
797
       
 
       
		rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")

     

       
798
       
 
       
		return

     

       
799
       
 
       
	}

     
···

       
804
       
 
       
		db.FilterContains("scope", tangled.RepoIssueNSID),

     

       
805
       
 
       
	)

     

       
806
       
 
       
	if err != nil {

     

       
807
       
-
       
		log.Println("failed to fetch labels", err)

     

       
808
       
 
       
		rp.pages.Error503(w)

     

       
809
       
 
       
		return

     

       
810
       
 
       
	}

     
···

       
901
       
 
       


     

       
902
       
 
       
		err = db.PutIssue(tx, issue)

     

       
903
       
 
       
		if err != nil {

     

       
904
       
-
       
			log.Println("failed to create issue", err)

     

       
905
       
 
       
			rp.pages.Notice(w, "issues", "Failed to create issue.")

     

       
906
       
 
       
			return

     

       
907
       
 
       
		}

     

       
908
       
 
       


     

       
909
       
 
       
		if err = tx.Commit(); err != nil {

     

       
910
       
-
       
			log.Println("failed to create issue", err)

     

       
911
       
 
       
			rp.pages.Notice(w, "issues", "Failed to create issue.")

     

       
912
       
 
       
			return

     

       
913
       
 
       
		}

     

···

       
5
       
 
       
	"database/sql"

     

       
6
       
 
       
	"errors"

     

       
7
       
 
       
	"fmt"

     

       
0
       
 
       

     

       
8
       
 
       
	"log/slog"

     

       
9
       
 
       
	"net/http"

     

       
10
       
 
       
	"slices"

     
···

       
27
       
 
       
	"tangled.org/core/appview/reporesolver"

     

       
28
       
 
       
	"tangled.org/core/appview/validator"

     

       
29
       
 
       
	"tangled.org/core/idresolver"

     

       
0
       
 
       

     

       
30
       
 
       
	"tangled.org/core/tid"

     

       
31
       
 
       
)

     

       
32
       
 
       


     
···

       
51
       
 
       
	config *config.Config,

     

       
52
       
 
       
	notifier notify.Notifier,

     

       
53
       
 
       
	validator *validator.Validator,

     

       
54
       
+
       
	logger *slog.Logger,

     

       
55
       
 
       
) *Issues {

     

       
56
       
 
       
	return &Issues{

     

       
57
       
 
       
		oauth:        oauth,

     
···

       
61
       
 
       
		db:           db,

     

       
62
       
 
       
		config:       config,

     

       
63
       
 
       
		notifier:     notifier,

     

       
64
       
+
       
		logger:       logger,

     

       
65
       
 
       
		validator:    validator,

     

       
66
       
 
       
	}

     

       
67
       
 
       
}

     
···

       
71
       
 
       
	user := rp.oauth.GetUser(r)

     

       
72
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
73
       
 
       
	if err != nil {

     

       
74
       
+
       
		l.Error("failed to get repo and knot", "err", err)

     

       
75
       
 
       
		return

     

       
76
       
 
       
	}

     

       
77
       
 
       


     
···

       
98
       
 
       
		db.FilterContains("scope", tangled.RepoIssueNSID),

     

       
99
       
 
       
	)

     

       
100
       
 
       
	if err != nil {

     

       
101
       
+
       
		l.Error("failed to fetch labels", "err", err)

     

       
102
       
 
       
		rp.pages.Error503(w)

     

       
103
       
 
       
		return

     

       
104
       
 
       
	}

     
···

       
125
       
 
       
	user := rp.oauth.GetUser(r)

     

       
126
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
127
       
 
       
	if err != nil {

     

       
128
       
+
       
		l.Error("failed to get repo and knot", "err", err)

     

       
129
       
 
       
		return

     

       
130
       
 
       
	}

     

       
131
       
 
       


     
···

       
198
       
 
       


     

       
199
       
 
       
		err = db.PutIssue(tx, newIssue)

     

       
200
       
 
       
		if err != nil {

     

       
201
       
+
       
			l.Error("failed to edit issue", "err", err)

     

       
202
       
 
       
			rp.pages.Notice(w, "issues", "Failed to edit issue.")

     

       
203
       
 
       
			return

     

       
204
       
 
       
		}

     
···

       
236
       
 
       
	// delete from PDS

     

       
237
       
 
       
	client, err := rp.oauth.AuthorizedClient(r)

     

       
238
       
 
       
	if err != nil {

     

       
239
       
+
       
		l.Error("failed to get authorized client", "err", err)

     

       
240
       
 
       
		rp.pages.Notice(w, "issue-comment", "Failed to delete comment.")

     

       
241
       
 
       
		return

     

       
242
       
 
       
	}

     
···

       
281
       
 
       


     

       
282
       
 
       
	collaborators, err := f.Collaborators(r.Context())

     

       
283
       
 
       
	if err != nil {

     

       
284
       
+
       
		l.Error("failed to fetch repo collaborators", "err", err)

     

       
285
       
 
       
	}

     

       
286
       
 
       
	isCollaborator := slices.ContainsFunc(collaborators, func(collab pages.Collaborator) bool {

     

       
287
       
 
       
		return user.Did == collab.Did

     
···

       
295
       
 
       
			db.FilterEq("id", issue.Id),

     

       
296
       
 
       
		)

     

       
297
       
 
       
		if err != nil {

     

       
298
       
+
       
			l.Error("failed to close issue", "err", err)

     

       
299
       
 
       
			rp.pages.Notice(w, "issue-action", "Failed to close issue. Try again later.")

     

       
300
       
 
       
			return

     

       
301
       
 
       
		}

     
···

       
306
       
 
       
		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId))

     

       
307
       
 
       
		return

     

       
308
       
 
       
	} else {

     

       
309
       
+
       
		l.Error("user is not permitted to close issue")

     

       
310
       
 
       
		http.Error(w, "for biden", http.StatusUnauthorized)

     

       
311
       
 
       
		return

     

       
312
       
 
       
	}

     
···

       
317
       
 
       
	user := rp.oauth.GetUser(r)

     

       
318
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
319
       
 
       
	if err != nil {

     

       
320
       
+
       
		l.Error("failed to get repo and knot", "err", err)

     

       
321
       
 
       
		return

     

       
322
       
 
       
	}

     

       
323
       
 
       


     
···

       
330
       
 
       


     

       
331
       
 
       
	collaborators, err := f.Collaborators(r.Context())

     

       
332
       
 
       
	if err != nil {

     

       
333
       
+
       
		l.Error("failed to fetch repo collaborators", "err", err)

     

       
334
       
 
       
	}

     

       
335
       
 
       
	isCollaborator := slices.ContainsFunc(collaborators, func(collab pages.Collaborator) bool {

     

       
336
       
 
       
		return user.Did == collab.Did

     
···

       
343
       
 
       
			db.FilterEq("id", issue.Id),

     

       
344
       
 
       
		)

     

       
345
       
 
       
		if err != nil {

     

       
346
       
+
       
			l.Error("failed to reopen issue", "err", err)

     

       
347
       
 
       
			rp.pages.Notice(w, "issue-action", "Failed to reopen issue. Try again later.")

     

       
348
       
 
       
			return

     

       
349
       
 
       
		}

     

       
350
       
 
       
		rp.pages.HxLocation(w, fmt.Sprintf("/%s/issues/%d", f.OwnerSlashRepo(), issue.IssueId))

     

       
351
       
 
       
		return

     

       
352
       
 
       
	} else {

     

       
353
       
+
       
		l.Error("user is not the owner of the repo")

     

       
354
       
 
       
		http.Error(w, "forbidden", http.StatusUnauthorized)

     

       
355
       
 
       
		return

     

       
356
       
 
       
	}

     
···

       
537
       
 
       
		newBody := r.FormValue("body")

     

       
538
       
 
       
		client, err := rp.oauth.AuthorizedClient(r)

     

       
539
       
 
       
		if err != nil {

     

       
540
       
+
       
			l.Error("failed to get authorized client", "err", err)

     

       
541
       
 
       
			rp.pages.Notice(w, "issue-comment", "Failed to create comment.")

     

       
542
       
 
       
			return

     

       
543
       
 
       
		}

     
···

       
550
       
 
       


     

       
551
       
 
       
		_, err = db.AddIssueComment(rp.db, newComment)

     

       
552
       
 
       
		if err != nil {

     

       
553
       
+
       
			l.Error("failed to perferom update-description query", "err", err)

     

       
554
       
 
       
			rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.")

     

       
555
       
 
       
			return

     

       
556
       
 
       
		}

     
···

       
560
       
 
       
			// update the record on pds

     

       
561
       
 
       
			ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoIssueCommentNSID, user.Did, comment.Rkey)

     

       
562
       
 
       
			if err != nil {

     

       
563
       
+
       
				l.Error("failed to get record", "err", err, "did", newComment.Did, "rkey", newComment.Rkey)

     

       
564
       
 
       
				rp.pages.Notice(w, fmt.Sprintf("comment-%s-status", commentId), "Failed to update description, no record found on PDS.")

     

       
565
       
 
       
				return

     

       
566
       
 
       
			}

     
···

       
728
       
 
       
	if comment.Rkey != "" {

     

       
729
       
 
       
		client, err := rp.oauth.AuthorizedClient(r)

     

       
730
       
 
       
		if err != nil {

     

       
731
       
+
       
			l.Error("failed to get authorized client", "err", err)

     

       
732
       
 
       
			rp.pages.Notice(w, "issue-comment", "Failed to delete comment.")

     

       
733
       
 
       
			return

     

       
734
       
 
       
		}

     
···

       
738
       
 
       
			Rkey:       comment.Rkey,

     

       
739
       
 
       
		})

     

       
740
       
 
       
		if err != nil {

     

       
741
       
+
       
			l.Error("failed to delete from PDS", "err", err)

     

       
742
       
 
       
		}

     

       
743
       
 
       
	}

     

       
744
       
 
       


     
···

       
756
       
 
       
}

     

       
757
       
 
       


     

       
758
       
 
       
func (rp *Issues) RepoIssues(w http.ResponseWriter, r *http.Request) {

     

       
759
       
+
       
	l := rp.logger.With("handler", "RepoIssues")

     

       
760
       
+
       


     

       
761
       
 
       
	params := r.URL.Query()

     

       
762
       
 
       
	state := params.Get("state")

     

       
763
       
 
       
	isOpen := true

     
···

       
772
       
 
       


     

       
773
       
 
       
	page, ok := r.Context().Value("page").(pagination.Page)

     

       
774
       
 
       
	if !ok {

     

       
775
       
+
       
		l.Error("failed to get page")

     

       
776
       
 
       
		page = pagination.FirstPage()

     

       
777
       
 
       
	}

     

       
778
       
 
       


     

       
779
       
 
       
	user := rp.oauth.GetUser(r)

     

       
780
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
781
       
 
       
	if err != nil {

     

       
782
       
+
       
		l.Error("failed to get repo and knot", "err", err)

     

       
783
       
 
       
		return

     

       
784
       
 
       
	}

     

       
785
       
 
       


     
···

       
794
       
 
       
		db.FilterEq("open", openVal),

     

       
795
       
 
       
	)

     

       
796
       
 
       
	if err != nil {

     

       
797
       
+
       
		l.Error("failed to get issues", "err", err)

     

       
798
       
 
       
		rp.pages.Notice(w, "issues", "Failed to load issues. Try again later.")

     

       
799
       
 
       
		return

     

       
800
       
 
       
	}

     
···

       
805
       
 
       
		db.FilterContains("scope", tangled.RepoIssueNSID),

     

       
806
       
 
       
	)

     

       
807
       
 
       
	if err != nil {

     

       
808
       
+
       
		l.Error("failed to fetch labels", "err", err)

     

       
809
       
 
       
		rp.pages.Error503(w)

     

       
810
       
 
       
		return

     

       
811
       
 
       
	}

     
···

       
902
       
 
       


     

       
903
       
 
       
		err = db.PutIssue(tx, issue)

     

       
904
       
 
       
		if err != nil {

     

       
905
       
+
       
			l.Error("failed to create issue", "err", err)

     

       
906
       
 
       
			rp.pages.Notice(w, "issues", "Failed to create issue.")

     

       
907
       
 
       
			return

     

       
908
       
 
       
		}

     

       
909
       
 
       


     

       
910
       
 
       
		if err = tx.Commit(); err != nil {

     

       
911
       
+
       
			l.Error("failed to create issue", "err", err)

     

       
912
       
 
       
			rp.pages.Notice(w, "issues", "Failed to create issue.")

     

       
913
       
 
       
			return

     

       
914
       
 
       
		}

     

···

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

     

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

     

       
18
       
 
       
	"tangled.org/core/appview/validator"

     

       
19
       
-
       
	"tangled.org/core/log"

     

       
20
       
 
       
	"tangled.org/core/rbac"

     

       
21
       
 
       
	"tangled.org/core/tid"

     

       
22
       
 
       


     
···

       
42
       
 
       
	db *db.DB,

     

       
43
       
 
       
	validator *validator.Validator,

     

       
44
       
 
       
	enforcer *rbac.Enforcer,

     

       
0
       
 
       

     

       
45
       
 
       
) *Labels {

     

       
46
       
-
       
	logger := log.New("labels")

     

       
47
       
-
       


     

       
48
       
 
       
	return &Labels{

     

       
49
       
 
       
		oauth:     oauth,

     

       
50
       
 
       
		pages:     pages,

     

···

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

     

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

     

       
18
       
 
       
	"tangled.org/core/appview/validator"

     

       
0
       
 
       

     

       
19
       
 
       
	"tangled.org/core/rbac"

     

       
20
       
 
       
	"tangled.org/core/tid"

     

       
21
       
 
       


     
···

       
41
       
 
       
	db *db.DB,

     

       
42
       
 
       
	validator *validator.Validator,

     

       
43
       
 
       
	enforcer *rbac.Enforcer,

     

       
44
       
+
       
	logger *slog.Logger,

     

       
45
       
 
       
) *Labels {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
46
       
 
       
	return &Labels{

     

       
47
       
 
       
		oauth:     oauth,

     

       
48
       
 
       
		pages:     pages,

     

···

       
1
       
 
       
package notifications

     

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
-
       
	"log"

     

       
5
       
 
       
	"net/http"

     

       
6
       
 
       
	"strconv"

     

       
7
       
 
       


     
···

       
14
       
 
       
)

     

       
15
       
 
       


     

       
16
       
 
       
type Notifications struct {

     

       
17
       
-
       
	db    *db.DB

     

       
18
       
-
       
	oauth *oauth.OAuth

     

       
19
       
-
       
	pages *pages.Pages

     

       
0
       
 
       

     

       
20
       
 
       
}

     

       
21
       
 
       


     

       
22
       
-
       
func New(database *db.DB, oauthHandler *oauth.OAuth, pagesHandler *pages.Pages) *Notifications {

     

       
23
       
 
       
	return &Notifications{

     

       
24
       
-
       
		db:    database,

     

       
25
       
-
       
		oauth: oauthHandler,

     

       
26
       
-
       
		pages: pagesHandler,

     

       
0
       
 
       

     

       
27
       
 
       
	}

     

       
28
       
 
       
}

     

       
29
       
 
       


     
···

       
44
       
 
       
}

     

       
45
       
 
       


     

       
46
       
 
       
func (n *Notifications) notificationsPage(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
47
       
 
       
	user := n.oauth.GetUser(r)

     

       
48
       
 
       


     

       
49
       
 
       
	page, ok := r.Context().Value("page").(pagination.Page)

     

       
50
       
 
       
	if !ok {

     

       
51
       
-
       
		log.Println("failed to get page")

     

       
52
       
 
       
		page = pagination.FirstPage()

     

       
53
       
 
       
	}

     

       
54
       
 
       


     
···

       
57
       
 
       
		db.FilterEq("recipient_did", user.Did),

     

       
58
       
 
       
	)

     

       
59
       
 
       
	if err != nil {

     

       
60
       
-
       
		log.Println("failed to get total notifications:", err)

     

       
61
       
 
       
		n.pages.Error500(w)

     

       
62
       
 
       
		return

     

       
63
       
 
       
	}

     
···

       
68
       
 
       
		db.FilterEq("recipient_did", user.Did),

     

       
69
       
 
       
	)

     

       
70
       
 
       
	if err != nil {

     

       
71
       
-
       
		log.Println("failed to get notifications:", err)

     

       
72
       
 
       
		n.pages.Error500(w)

     

       
73
       
 
       
		return

     

       
74
       
 
       
	}

     

       
75
       
 
       


     

       
76
       
 
       
	err = n.db.MarkAllNotificationsRead(r.Context(), user.Did)

     

       
77
       
 
       
	if err != nil {

     

       
78
       
-
       
		log.Println("failed to mark notifications as read:", err)

     

       
79
       
 
       
	}

     

       
80
       
 
       


     

       
81
       
 
       
	unreadCount := 0

     

···

       
1
       
 
       
package notifications

     

       
2
       
 
       


     

       
3
       
 
       
import (

     

       
4
       
+
       
	"log/slog"

     

       
5
       
 
       
	"net/http"

     

       
6
       
 
       
	"strconv"

     

       
7
       
 
       


     
···

       
14
       
 
       
)

     

       
15
       
 
       


     

       
16
       
 
       
type Notifications struct {

     

       
17
       
+
       
	db     *db.DB

     

       
18
       
+
       
	oauth  *oauth.OAuth

     

       
19
       
+
       
	pages  *pages.Pages

     

       
20
       
+
       
	logger *slog.Logger

     

       
21
       
 
       
}

     

       
22
       
 
       


     

       
23
       
+
       
func New(database *db.DB, oauthHandler *oauth.OAuth, pagesHandler *pages.Pages, logger *slog.Logger) *Notifications {

     

       
24
       
 
       
	return &Notifications{

     

       
25
       
+
       
		db:     database,

     

       
26
       
+
       
		oauth:  oauthHandler,

     

       
27
       
+
       
		pages:  pagesHandler,

     

       
28
       
+
       
		logger: logger,

     

       
29
       
 
       
	}

     

       
30
       
 
       
}

     

       
31
       
 
       


     
···

       
46
       
 
       
}

     

       
47
       
 
       


     

       
48
       
 
       
func (n *Notifications) notificationsPage(w http.ResponseWriter, r *http.Request) {

     

       
49
       
+
       
	l := n.logger.With("handler", "notificationsPage")

     

       
50
       
 
       
	user := n.oauth.GetUser(r)

     

       
51
       
 
       


     

       
52
       
 
       
	page, ok := r.Context().Value("page").(pagination.Page)

     

       
53
       
 
       
	if !ok {

     

       
54
       
+
       
		l.Error("failed to get page")

     

       
55
       
 
       
		page = pagination.FirstPage()

     

       
56
       
 
       
	}

     

       
57
       
 
       


     
···

       
60
       
 
       
		db.FilterEq("recipient_did", user.Did),

     

       
61
       
 
       
	)

     

       
62
       
 
       
	if err != nil {

     

       
63
       
+
       
		l.Error("failed to get total notifications", "err", err)

     

       
64
       
 
       
		n.pages.Error500(w)

     

       
65
       
 
       
		return

     

       
66
       
 
       
	}

     
···

       
71
       
 
       
		db.FilterEq("recipient_did", user.Did),

     

       
72
       
 
       
	)

     

       
73
       
 
       
	if err != nil {

     

       
74
       
+
       
		l.Error("failed to get notifications", "err", err)

     

       
75
       
 
       
		n.pages.Error500(w)

     

       
76
       
 
       
		return

     

       
77
       
 
       
	}

     

       
78
       
 
       


     

       
79
       
 
       
	err = n.db.MarkAllNotificationsRead(r.Context(), user.Did)

     

       
80
       
 
       
	if err != nil {

     

       
81
       
+
       
		l.Error("failed to mark notifications as read", "err", err)

     

       
82
       
 
       
	}

     

       
83
       
 
       


     

       
84
       
 
       
	unreadCount := 0

     

···

       
54
       
 
       
	logger      *slog.Logger

     

       
55
       
 
       
}

     

       
56
       
 
       


     

       
57
       
-
       
func NewPages(config *config.Config, res *idresolver.Resolver) *Pages {

     

       
58
       
 
       
	// initialized with safe defaults, can be overriden per use

     

       
59
       
 
       
	rctx := &markup.RenderContext{

     

       
60
       
 
       
		IsDev:      config.Core.Dev,

     
···

       
72
       
 
       
		rctx:        rctx,

     

       
73
       
 
       
		resolver:    res,

     

       
74
       
 
       
		templateDir: "appview/pages",

     

       
75
       
-
       
		logger:      slog.Default().With("component", "pages"),

     

       
76
       
 
       
	}

     

       
77
       
 
       


     

       
78
       
 
       
	if p.dev {

     

···

       
54
       
 
       
	logger      *slog.Logger

     

       
55
       
 
       
}

     

       
56
       
 
       


     

       
57
       
+
       
func NewPages(config *config.Config, res *idresolver.Resolver, logger *slog.Logger) *Pages {

     

       
58
       
 
       
	// initialized with safe defaults, can be overriden per use

     

       
59
       
 
       
	rctx := &markup.RenderContext{

     

       
60
       
 
       
		IsDev:      config.Core.Dev,

     
···

       
72
       
 
       
		rctx:        rctx,

     

       
73
       
 
       
		resolver:    res,

     

       
74
       
 
       
		templateDir: "appview/pages",

     

       
75
       
+
       
		logger:      logger,

     

       
76
       
 
       
	}

     

       
77
       
 
       


     

       
78
       
 
       
	if p.dev {

     

···

       
16
       
 
       
	"tangled.org/core/appview/reporesolver"

     

       
17
       
 
       
	"tangled.org/core/eventconsumer"

     

       
18
       
 
       
	"tangled.org/core/idresolver"

     

       
19
       
-
       
	"tangled.org/core/log"

     

       
20
       
 
       
	"tangled.org/core/rbac"

     

       
21
       
 
       
	spindlemodel "tangled.org/core/spindle/models"

     

       
22
       
 
       


     
···

       
45
       
 
       
	db *db.DB,

     

       
46
       
 
       
	config *config.Config,

     

       
47
       
 
       
	enforcer *rbac.Enforcer,

     

       
0
       
 
       

     

       
48
       
 
       
) *Pipelines {

     

       
49
       
-
       
	logger := log.New("pipelines")

     

       
50
       
-
       


     

       
51
       
 
       
	return &Pipelines{

     

       
52
       
 
       
		oauth:         oauth,

     

       
53
       
 
       
		repoResolver:  repoResolver,

     

···

       
16
       
 
       
	"tangled.org/core/appview/reporesolver"

     

       
17
       
 
       
	"tangled.org/core/eventconsumer"

     

       
18
       
 
       
	"tangled.org/core/idresolver"

     

       
0
       
 
       

     

       
19
       
 
       
	"tangled.org/core/rbac"

     

       
20
       
 
       
	spindlemodel "tangled.org/core/spindle/models"

     

       
21
       
 
       


     
···

       
44
       
 
       
	db *db.DB,

     

       
45
       
 
       
	config *config.Config,

     

       
46
       
 
       
	enforcer *rbac.Enforcer,

     

       
47
       
+
       
	logger *slog.Logger,

     

       
48
       
 
       
) *Pipelines {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
49
       
 
       
	return &Pipelines{

     

       
50
       
 
       
		oauth:         oauth,

     

       
51
       
 
       
		repoResolver:  repoResolver,

     

···

       
6
       
 
       
	"errors"

     

       
7
       
 
       
	"fmt"

     

       
8
       
 
       
	"log"

     

       
0
       
 
       

     

       
9
       
 
       
	"net/http"

     

       
10
       
 
       
	"slices"

     

       
11
       
 
       
	"sort"

     
···

       
46
       
 
       
	config       *config.Config

     

       
47
       
 
       
	notifier     notify.Notifier

     

       
48
       
 
       
	enforcer     *rbac.Enforcer

     

       
0
       
 
       

     

       
49
       
 
       
}

     

       
50
       
 
       


     

       
51
       
 
       
func New(

     
···

       
57
       
 
       
	config *config.Config,

     

       
58
       
 
       
	notifier notify.Notifier,

     

       
59
       
 
       
	enforcer *rbac.Enforcer,

     

       
0
       
 
       

     

       
60
       
 
       
) *Pulls {

     

       
61
       
 
       
	return &Pulls{

     

       
62
       
 
       
		oauth:        oauth,

     
···

       
67
       
 
       
		config:       config,

     

       
68
       
 
       
		notifier:     notifier,

     

       
69
       
 
       
		enforcer:     enforcer,

     

       
0
       
 
       

     

       
70
       
 
       
	}

     

       
71
       
 
       
}

     

       
72
       
 
       


     

···

       
6
       
 
       
	"errors"

     

       
7
       
 
       
	"fmt"

     

       
8
       
 
       
	"log"

     

       
9
       
+
       
	"log/slog"

     

       
10
       
 
       
	"net/http"

     

       
11
       
 
       
	"slices"

     

       
12
       
 
       
	"sort"

     
···

       
47
       
 
       
	config       *config.Config

     

       
48
       
 
       
	notifier     notify.Notifier

     

       
49
       
 
       
	enforcer     *rbac.Enforcer

     

       
50
       
+
       
	logger       *slog.Logger

     

       
51
       
 
       
}

     

       
52
       
 
       


     

       
53
       
 
       
func New(

     
···

       
59
       
 
       
	config *config.Config,

     

       
60
       
 
       
	notifier notify.Notifier,

     

       
61
       
 
       
	enforcer *rbac.Enforcer,

     

       
62
       
+
       
	logger *slog.Logger,

     

       
63
       
 
       
) *Pulls {

     

       
64
       
 
       
	return &Pulls{

     

       
65
       
 
       
		oauth:        oauth,

     
···

       
70
       
 
       
		config:       config,

     

       
71
       
 
       
		notifier:     notifier,

     

       
72
       
 
       
		enforcer:     enforcer,

     

       
73
       
+
       
		logger:       logger,

     

       
74
       
 
       
	}

     

       
75
       
 
       
}

     

       
76
       
 
       


     

···

       
3
       
 
       
import (

     

       
4
       
 
       
	"errors"

     

       
5
       
 
       
	"fmt"

     

       
6
       
-
       
	"log"

     

       
7
       
 
       
	"net/http"

     

       
8
       
 
       
	"net/url"

     

       
9
       
 
       
	"slices"

     
···

       
31
       
 
       
)

     

       
32
       
 
       


     

       
33
       
 
       
func (rp *Repo) RepoIndex(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
34
       
 
       
	ref := chi.URLParam(r, "ref")

     

       
35
       
 
       
	ref, _ = url.PathUnescape(ref)

     

       
36
       
 
       


     

       
37
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
38
       
 
       
	if err != nil {

     

       
39
       
-
       
		log.Println("failed to fully resolve repo", err)

     

       
40
       
 
       
		return

     

       
41
       
 
       
	}

     

       
42
       
 
       


     
···

       
56
       
 
       
	result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)

     

       
57
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
58
       
 
       
		if errors.Is(xrpcerr, xrpcclient.ErrXrpcUnsupported) {

     

       
59
       
-
       
			log.Println("failed to call XRPC repo.index", err)

     

       
60
       
 
       
			rp.pages.RepoIndexPage(w, pages.RepoIndexParams{

     

       
61
       
 
       
				LoggedInUser:     user,

     

       
62
       
 
       
				NeedsKnotUpgrade: true,

     
···

       
66
       
 
       
		}

     

       
67
       
 
       


     

       
68
       
 
       
		rp.pages.Error503(w)

     

       
69
       
-
       
		log.Println("failed to build index response", err)

     

       
70
       
 
       
		return

     

       
71
       
 
       
	}

     

       
72
       
 
       


     
···

       
119
       
 
       
	emails := uniqueEmails(commitsTrunc)

     

       
120
       
 
       
	emailToDidMap, err := db.GetEmailToDid(rp.db, emails, true)

     

       
121
       
 
       
	if err != nil {

     

       
122
       
-
       
		log.Println("failed to get email to did map", err)

     

       
123
       
 
       
	}

     

       
124
       
 
       


     

       
125
       
 
       
	vc, err := commitverify.GetVerifiedObjectCommits(rp.db, emailToDidMap, commitsTrunc)

     

       
126
       
 
       
	if err != nil {

     

       
127
       
-
       
		log.Println(err)

     

       
128
       
 
       
	}

     

       
129
       
 
       


     

       
130
       
 
       
	// TODO: a bit dirty

     

       
131
       
-
       
	languageInfo, err := rp.getLanguageInfo(r.Context(), f, xrpcc, result.Ref, ref == "")

     

       
132
       
 
       
	if err != nil {

     

       
133
       
-
       
		log.Printf("failed to compute language percentages: %s", err)

     

       
134
       
 
       
		// non-fatal

     

       
135
       
 
       
	}

     

       
136
       
 
       


     
···

       
140
       
 
       
	}

     

       
141
       
 
       
	pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas)

     

       
142
       
 
       
	if err != nil {

     

       
143
       
-
       
		log.Printf("failed to fetch pipeline statuses: %s", err)

     

       
144
       
 
       
		// non-fatal

     

       
145
       
 
       
	}

     

       
146
       
 
       


     
···

       
162
       
 
       


     

       
163
       
 
       
func (rp *Repo) getLanguageInfo(

     

       
164
       
 
       
	ctx context.Context,

     

       
0
       
 
       

     

       
165
       
 
       
	f *reporesolver.ResolvedRepo,

     

       
166
       
 
       
	xrpcc *indigoxrpc.Client,

     

       
167
       
 
       
	currentRef string,

     
···

       
180
       
 
       
		ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, repo)

     

       
181
       
 
       
		if err != nil {

     

       
182
       
 
       
			if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
183
       
-
       
				log.Println("failed to call XRPC repo.languages", xrpcerr)

     

       
184
       
 
       
				return nil, xrpcerr

     

       
185
       
 
       
			}

     

       
186
       
 
       
			return nil, err

     
···

       
210
       
 
       
		err = db.UpdateRepoLanguages(tx, f.RepoAt(), currentRef, langs)

     

       
211
       
 
       
		if err != nil {

     

       
212
       
 
       
			// non-fatal

     

       
213
       
-
       
			log.Println("failed to cache lang results", err)

     

       
214
       
 
       
		}

     

       
215
       
 
       


     

       
216
       
 
       
		err = tx.Commit()

     

···

       
3
       
 
       
import (

     

       
4
       
 
       
	"errors"

     

       
5
       
 
       
	"fmt"

     

       
6
       
+
       
	"log/slog"

     

       
7
       
 
       
	"net/http"

     

       
8
       
 
       
	"net/url"

     

       
9
       
 
       
	"slices"

     
···

       
31
       
 
       
)

     

       
32
       
 
       


     

       
33
       
 
       
func (rp *Repo) RepoIndex(w http.ResponseWriter, r *http.Request) {

     

       
34
       
+
       
	l := rp.logger.With("handler", "RepoIndex")

     

       
35
       
+
       


     

       
36
       
 
       
	ref := chi.URLParam(r, "ref")

     

       
37
       
 
       
	ref, _ = url.PathUnescape(ref)

     

       
38
       
 
       


     

       
39
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
40
       
 
       
	if err != nil {

     

       
41
       
+
       
		l.Error("failed to fully resolve repo", "err", err)

     

       
42
       
 
       
		return

     

       
43
       
 
       
	}

     

       
44
       
 
       


     
···

       
58
       
 
       
	result, err := rp.buildIndexResponse(r.Context(), xrpcc, f, ref)

     

       
59
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
60
       
 
       
		if errors.Is(xrpcerr, xrpcclient.ErrXrpcUnsupported) {

     

       
61
       
+
       
			l.Error("failed to call XRPC repo.index", "err", err)

     

       
62
       
 
       
			rp.pages.RepoIndexPage(w, pages.RepoIndexParams{

     

       
63
       
 
       
				LoggedInUser:     user,

     

       
64
       
 
       
				NeedsKnotUpgrade: true,

     
···

       
68
       
 
       
		}

     

       
69
       
 
       


     

       
70
       
 
       
		rp.pages.Error503(w)

     

       
71
       
+
       
		l.Error("failed to build index response", "err", err)

     

       
72
       
 
       
		return

     

       
73
       
 
       
	}

     

       
74
       
 
       


     
···

       
121
       
 
       
	emails := uniqueEmails(commitsTrunc)

     

       
122
       
 
       
	emailToDidMap, err := db.GetEmailToDid(rp.db, emails, true)

     

       
123
       
 
       
	if err != nil {

     

       
124
       
+
       
		l.Error("failed to get email to did map", "err", err)

     

       
125
       
 
       
	}

     

       
126
       
 
       


     

       
127
       
 
       
	vc, err := commitverify.GetVerifiedObjectCommits(rp.db, emailToDidMap, commitsTrunc)

     

       
128
       
 
       
	if err != nil {

     

       
129
       
+
       
		l.Error("failed to GetVerifiedObjectCommits", "err", err)

     

       
130
       
 
       
	}

     

       
131
       
 
       


     

       
132
       
 
       
	// TODO: a bit dirty

     

       
133
       
+
       
	languageInfo, err := rp.getLanguageInfo(r.Context(), l, f, xrpcc, result.Ref, ref == "")

     

       
134
       
 
       
	if err != nil {

     

       
135
       
+
       
		l.Warn("failed to compute language percentages", "err", err)

     

       
136
       
 
       
		// non-fatal

     

       
137
       
 
       
	}

     

       
138
       
 
       


     
···

       
142
       
 
       
	}

     

       
143
       
 
       
	pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas)

     

       
144
       
 
       
	if err != nil {

     

       
145
       
+
       
		l.Error("failed to fetch pipeline statuses", "err", err)

     

       
146
       
 
       
		// non-fatal

     

       
147
       
 
       
	}

     

       
148
       
 
       


     
···

       
164
       
 
       


     

       
165
       
 
       
func (rp *Repo) getLanguageInfo(

     

       
166
       
 
       
	ctx context.Context,

     

       
167
       
+
       
	l *slog.Logger,

     

       
168
       
 
       
	f *reporesolver.ResolvedRepo,

     

       
169
       
 
       
	xrpcc *indigoxrpc.Client,

     

       
170
       
 
       
	currentRef string,

     
···

       
183
       
 
       
		ls, err := tangled.RepoLanguages(ctx, xrpcc, currentRef, repo)

     

       
184
       
 
       
		if err != nil {

     

       
185
       
 
       
			if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
186
       
+
       
				l.Error("failed to call XRPC repo.languages", "err", xrpcerr)

     

       
187
       
 
       
				return nil, xrpcerr

     

       
188
       
 
       
			}

     

       
189
       
 
       
			return nil, err

     
···

       
213
       
 
       
		err = db.UpdateRepoLanguages(tx, f.RepoAt(), currentRef, langs)

     

       
214
       
 
       
		if err != nil {

     

       
215
       
 
       
			// non-fatal

     

       
216
       
+
       
			l.Error("failed to cache lang results", "err", err)

     

       
217
       
 
       
		}

     

       
218
       
 
       


     

       
219
       
 
       
		err = tx.Commit()

     

···

       
7
       
 
       
	"errors"

     

       
8
       
 
       
	"fmt"

     

       
9
       
 
       
	"io"

     

       
10
       
-
       
	"log"

     

       
11
       
 
       
	"log/slog"

     

       
12
       
 
       
	"net/http"

     

       
13
       
 
       
	"net/url"

     
···

       
90
       
 
       
}

     

       
91
       
 
       


     

       
92
       
 
       
func (rp *Repo) DownloadArchive(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
93
       
 
       
	ref := chi.URLParam(r, "ref")

     

       
94
       
 
       
	ref, _ = url.PathUnescape(ref)

     

       
95
       
 
       


     

       
96
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
97
       
 
       
	if err != nil {

     

       
98
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
99
       
 
       
		return

     

       
100
       
 
       
	}

     

       
101
       
 
       


     
···

       
111
       
 
       
	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       
112
       
 
       
	archiveBytes, err := tangled.RepoArchive(r.Context(), xrpcc, "tar.gz", "", ref, repo)

     

       
113
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
114
       
-
       
		log.Println("failed to call XRPC repo.archive", xrpcerr)

     

       
115
       
 
       
		rp.pages.Error503(w)

     

       
116
       
 
       
		return

     

       
117
       
 
       
	}

     
···

       
128
       
 
       
}

     

       
129
       
 
       


     

       
130
       
 
       
func (rp *Repo) RepoLog(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
131
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
132
       
 
       
	if err != nil {

     

       
133
       
-
       
		log.Println("failed to fully resolve repo", err)

     

       
134
       
 
       
		return

     

       
135
       
 
       
	}

     

       
136
       
 
       


     
···

       
165
       
 
       
	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       
166
       
 
       
	xrpcBytes, err := tangled.RepoLog(r.Context(), xrpcc, cursor, limit, "", ref, repo)

     

       
167
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
168
       
-
       
		log.Println("failed to call XRPC repo.log", xrpcerr)

     

       
169
       
 
       
		rp.pages.Error503(w)

     

       
170
       
 
       
		return

     

       
171
       
 
       
	}

     

       
172
       
 
       


     

       
173
       
 
       
	var xrpcResp types.RepoLogResponse

     

       
174
       
 
       
	if err := json.Unmarshal(xrpcBytes, &xrpcResp); err != nil {

     

       
175
       
-
       
		log.Println("failed to decode XRPC response", err)

     

       
176
       
 
       
		rp.pages.Error503(w)

     

       
177
       
 
       
		return

     

       
178
       
 
       
	}

     

       
179
       
 
       


     

       
180
       
 
       
	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       
181
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
182
       
-
       
		log.Println("failed to call XRPC repo.tags", xrpcerr)

     

       
183
       
 
       
		rp.pages.Error503(w)

     

       
184
       
 
       
		return

     

       
185
       
 
       
	}

     
···

       
196
       
 
       


     

       
197
       
 
       
	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       
198
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
199
       
-
       
		log.Println("failed to call XRPC repo.branches", xrpcerr)

     

       
200
       
 
       
		rp.pages.Error503(w)

     

       
201
       
 
       
		return

     

       
202
       
 
       
	}

     
···

       
214
       
 
       


     

       
215
       
 
       
	emailToDidMap, err := db.GetEmailToDid(rp.db, uniqueEmails(xrpcResp.Commits), true)

     

       
216
       
 
       
	if err != nil {

     

       
217
       
-
       
		log.Println("failed to fetch email to did mapping", err)

     

       
218
       
 
       
	}

     

       
219
       
 
       


     

       
220
       
 
       
	vc, err := commitverify.GetVerifiedObjectCommits(rp.db, emailToDidMap, xrpcResp.Commits)

     

       
221
       
 
       
	if err != nil {

     

       
222
       
-
       
		log.Println(err)

     

       
223
       
 
       
	}

     

       
224
       
 
       


     

       
225
       
 
       
	repoInfo := f.RepoInfo(user)

     
···

       
230
       
 
       
	}

     

       
231
       
 
       
	pipelines, err := getPipelineStatuses(rp.db, repoInfo, shas)

     

       
232
       
 
       
	if err != nil {

     

       
233
       
-
       
		log.Println(err)

     

       
234
       
 
       
		// non-fatal

     

       
235
       
 
       
	}

     

       
236
       
 
       


     
···

       
246
       
 
       
}

     

       
247
       
 
       


     

       
248
       
 
       
func (rp *Repo) RepoDescriptionEdit(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
249
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
250
       
 
       
	if err != nil {

     

       
251
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
252
       
 
       
		w.WriteHeader(http.StatusBadRequest)

     

       
253
       
 
       
		return

     

       
254
       
 
       
	}

     
···

       
260
       
 
       
}

     

       
261
       
 
       


     

       
262
       
 
       
func (rp *Repo) RepoDescription(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
263
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
264
       
 
       
	if err != nil {

     

       
265
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
266
       
 
       
		w.WriteHeader(http.StatusBadRequest)

     

       
267
       
 
       
		return

     

       
268
       
 
       
	}

     
···

       
270
       
 
       
	repoAt := f.RepoAt()

     

       
271
       
 
       
	rkey := repoAt.RecordKey().String()

     

       
272
       
 
       
	if rkey == "" {

     

       
273
       
-
       
		log.Println("invalid aturi for repo", err)

     

       
274
       
 
       
		w.WriteHeader(http.StatusInternalServerError)

     

       
275
       
 
       
		return

     

       
276
       
 
       
	}

     
···

       
287
       
 
       
		newDescription := r.FormValue("description")

     

       
288
       
 
       
		client, err := rp.oauth.AuthorizedClient(r)

     

       
289
       
 
       
		if err != nil {

     

       
290
       
-
       
			log.Println("failed to get client")

     

       
291
       
 
       
			rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.")

     

       
292
       
 
       
			return

     

       
293
       
 
       
		}

     
···

       
295
       
 
       
		// optimistic update

     

       
296
       
 
       
		err = db.UpdateDescription(rp.db, string(repoAt), newDescription)

     

       
297
       
 
       
		if err != nil {

     

       
298
       
-
       
			log.Println("failed to perferom update-description query", err)

     

       
299
       
 
       
			rp.pages.Notice(w, "repo-notice", "Failed to update description, try again later.")

     

       
300
       
 
       
			return

     

       
301
       
 
       
		}

     
···

       
324
       
 
       
		})

     

       
325
       
 
       


     

       
326
       
 
       
		if err != nil {

     

       
327
       
-
       
			log.Println("failed to perferom update-description query", err)

     

       
328
       
 
       
			// failed to get record

     

       
329
       
 
       
			rp.pages.Notice(w, "repo-notice", "Failed to update description, unable to save to PDS.")

     

       
330
       
 
       
			return

     
···

       
341
       
 
       
}

     

       
342
       
 
       


     

       
343
       
 
       
func (rp *Repo) RepoCommit(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
344
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
345
       
 
       
	if err != nil {

     

       
346
       
-
       
		log.Println("failed to fully resolve repo", err)

     

       
347
       
 
       
		return

     

       
348
       
 
       
	}

     

       
349
       
 
       
	ref := chi.URLParam(r, "ref")

     
···

       
371
       
 
       
	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       
372
       
 
       
	xrpcBytes, err := tangled.RepoDiff(r.Context(), xrpcc, ref, repo)

     

       
373
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
374
       
-
       
		log.Println("failed to call XRPC repo.diff", xrpcerr)

     

       
375
       
 
       
		rp.pages.Error503(w)

     

       
376
       
 
       
		return

     

       
377
       
 
       
	}

     

       
378
       
 
       


     

       
379
       
 
       
	var result types.RepoCommitResponse

     

       
380
       
 
       
	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       
381
       
-
       
		log.Println("failed to decode XRPC response", err)

     

       
382
       
 
       
		rp.pages.Error503(w)

     

       
383
       
 
       
		return

     

       
384
       
 
       
	}

     

       
385
       
 
       


     

       
386
       
 
       
	emailToDidMap, err := db.GetEmailToDid(rp.db, []string{result.Diff.Commit.Committer.Email, result.Diff.Commit.Author.Email}, true)

     

       
387
       
 
       
	if err != nil {

     

       
388
       
-
       
		log.Println("failed to get email to did mapping:", err)

     

       
389
       
 
       
	}

     

       
390
       
 
       


     

       
391
       
 
       
	vc, err := commitverify.GetVerifiedCommits(rp.db, emailToDidMap, []types.NiceDiff{*result.Diff})

     

       
392
       
 
       
	if err != nil {

     

       
393
       
-
       
		log.Println(err)

     

       
394
       
 
       
	}

     

       
395
       
 
       


     

       
396
       
 
       
	user := rp.oauth.GetUser(r)

     

       
397
       
 
       
	repoInfo := f.RepoInfo(user)

     

       
398
       
 
       
	pipelines, err := getPipelineStatuses(rp.db, repoInfo, []string{result.Diff.Commit.This})

     

       
399
       
 
       
	if err != nil {

     

       
400
       
-
       
		log.Println(err)

     

       
401
       
 
       
		// non-fatal

     

       
402
       
 
       
	}

     

       
403
       
 
       
	var pipeline *models.Pipeline

     
···

       
417
       
 
       
}

     

       
418
       
 
       


     

       
419
       
 
       
func (rp *Repo) RepoTree(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
420
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
421
       
 
       
	if err != nil {

     

       
422
       
-
       
		log.Println("failed to fully resolve repo", err)

     

       
423
       
 
       
		return

     

       
424
       
 
       
	}

     

       
425
       
 
       


     
···

       
444
       
 
       
	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       
445
       
 
       
	xrpcResp, err := tangled.RepoTree(r.Context(), xrpcc, treePath, ref, repo)

     

       
446
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
447
       
-
       
		log.Println("failed to call XRPC repo.tree", xrpcerr)

     

       
448
       
 
       
		rp.pages.Error503(w)

     

       
449
       
 
       
		return

     

       
450
       
 
       
	}

     
···

       
519
       
 
       
}

     

       
520
       
 
       


     

       
521
       
 
       
func (rp *Repo) RepoTags(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
522
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
523
       
 
       
	if err != nil {

     

       
524
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
525
       
 
       
		return

     

       
526
       
 
       
	}

     

       
527
       
 
       


     
···

       
537
       
 
       
	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       
538
       
 
       
	xrpcBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       
539
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
540
       
-
       
		log.Println("failed to call XRPC repo.tags", xrpcerr)

     

       
541
       
 
       
		rp.pages.Error503(w)

     

       
542
       
 
       
		return

     

       
543
       
 
       
	}

     

       
544
       
 
       


     

       
545
       
 
       
	var result types.RepoTagsResponse

     

       
546
       
 
       
	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       
547
       
-
       
		log.Println("failed to decode XRPC response", err)

     

       
548
       
 
       
		rp.pages.Error503(w)

     

       
549
       
 
       
		return

     

       
550
       
 
       
	}

     

       
551
       
 
       


     

       
552
       
 
       
	artifacts, err := db.GetArtifact(rp.db, db.FilterEq("repo_at", f.RepoAt()))

     

       
553
       
 
       
	if err != nil {

     

       
554
       
-
       
		log.Println("failed grab artifacts", err)

     

       
555
       
 
       
		return

     

       
556
       
 
       
	}

     

       
557
       
 
       


     
···

       
588
       
 
       
}

     

       
589
       
 
       


     

       
590
       
 
       
func (rp *Repo) RepoBranches(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
591
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
592
       
 
       
	if err != nil {

     

       
593
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
594
       
 
       
		return

     

       
595
       
 
       
	}

     

       
596
       
 
       


     
···

       
606
       
 
       
	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       
607
       
 
       
	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       
608
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
609
       
-
       
		log.Println("failed to call XRPC repo.branches", xrpcerr)

     

       
610
       
 
       
		rp.pages.Error503(w)

     

       
611
       
 
       
		return

     

       
612
       
 
       
	}

     

       
613
       
 
       


     

       
614
       
 
       
	var result types.RepoBranchesResponse

     

       
615
       
 
       
	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       
616
       
-
       
		log.Println("failed to decode XRPC response", err)

     

       
617
       
 
       
		rp.pages.Error503(w)

     

       
618
       
 
       
		return

     

       
619
       
 
       
	}

     
···

       
629
       
 
       
}

     

       
630
       
 
       


     

       
631
       
 
       
func (rp *Repo) DeleteBranch(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
632
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
633
       
 
       
	if err != nil {

     

       
634
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
635
       
 
       
		return

     

       
636
       
 
       
	}

     

       
637
       
 
       


     

       
638
       
 
       
	noticeId := "delete-branch-error"

     

       
639
       
 
       
	fail := func(msg string, err error) {

     

       
640
       
-
       
		log.Println(msg, "err", err)

     

       
641
       
 
       
		rp.pages.Notice(w, noticeId, msg)

     

       
642
       
 
       
	}

     

       
643
       
 
       


     
···

       
670
       
 
       
		fail(fmt.Sprintf("Failed to delete branch: %s", err), err)

     

       
671
       
 
       
		return

     

       
672
       
 
       
	}

     

       
673
       
-
       
	log.Println("deleted branch from knot", "branch", branch, "repo", f.RepoAt())

     

       
674
       
 
       


     

       
675
       
 
       
	rp.pages.HxRefresh(w)

     

       
676
       
 
       
}

     

       
677
       
 
       


     

       
678
       
 
       
func (rp *Repo) RepoBlob(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
679
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
680
       
 
       
	if err != nil {

     

       
681
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
682
       
 
       
		return

     

       
683
       
 
       
	}

     

       
684
       
 
       


     
···

       
700
       
 
       
	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Repo.Name)

     

       
701
       
 
       
	resp, err := tangled.RepoBlob(r.Context(), xrpcc, filePath, false, ref, repo)

     

       
702
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
703
       
-
       
		log.Println("failed to call XRPC repo.blob", xrpcerr)

     

       
704
       
 
       
		rp.pages.Error503(w)

     

       
705
       
 
       
		return

     

       
706
       
 
       
	}

     
···

       
800
       
 
       
}

     

       
801
       
 
       


     

       
802
       
 
       
func (rp *Repo) RepoBlobRaw(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
803
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
804
       
 
       
	if err != nil {

     

       
805
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
806
       
 
       
		w.WriteHeader(http.StatusBadRequest)

     

       
807
       
 
       
		return

     

       
808
       
 
       
	}

     
···

       
834
       
 
       


     

       
835
       
 
       
	req, err := http.NewRequest("GET", blobURL, nil)

     

       
836
       
 
       
	if err != nil {

     

       
837
       
-
       
		log.Println("failed to create request", err)

     

       
838
       
 
       
		return

     

       
839
       
 
       
	}

     

       
840
       
 
       


     
···

       
846
       
 
       
	client := &http.Client{}

     

       
847
       
 
       
	resp, err := client.Do(req)

     

       
848
       
 
       
	if err != nil {

     

       
849
       
-
       
		log.Println("failed to reach knotserver", err)

     

       
850
       
 
       
		rp.pages.Error503(w)

     

       
851
       
 
       
		return

     

       
852
       
 
       
	}

     
···

       
859
       
 
       
	}

     

       
860
       
 
       


     

       
861
       
 
       
	if resp.StatusCode != http.StatusOK {

     

       
862
       
-
       
		log.Printf("knotserver returned non-OK status for raw blob %s: %d", blobURL, resp.StatusCode)

     

       
863
       
 
       
		w.WriteHeader(resp.StatusCode)

     

       
864
       
 
       
		_, _ = io.Copy(w, resp.Body)

     

       
865
       
 
       
		return

     
···

       
868
       
 
       
	contentType := resp.Header.Get("Content-Type")

     

       
869
       
 
       
	body, err := io.ReadAll(resp.Body)

     

       
870
       
 
       
	if err != nil {

     

       
871
       
-
       
		log.Printf("error reading response body from knotserver: %v", err)

     

       
872
       
 
       
		w.WriteHeader(http.StatusInternalServerError)

     

       
873
       
 
       
		return

     

       
874
       
 
       
	}

     
···

       
1443
       
 
       
		db.FilterContains("scope", subject.Collection().String()),

     

       
1444
       
 
       
	)

     

       
1445
       
 
       
	if err != nil {

     

       
1446
       
-
       
		log.Println("failed to fetch label defs", err)

     

       
1447
       
 
       
		return

     

       
1448
       
 
       
	}

     

       
1449
       
 
       


     
···

       
1454
       
 
       


     

       
1455
       
 
       
	states, err := db.GetLabels(rp.db, db.FilterEq("subject", subject))

     

       
1456
       
 
       
	if err != nil {

     

       
1457
       
-
       
		log.Println("failed to build label state", err)

     

       
1458
       
 
       
		return

     

       
1459
       
 
       
	}

     

       
1460
       
 
       
	state := states[subject]

     
···

       
1491
       
 
       
		db.FilterContains("scope", subject.Collection().String()),

     

       
1492
       
 
       
	)

     

       
1493
       
 
       
	if err != nil {

     

       
1494
       
-
       
		log.Println("failed to fetch labels", err)

     

       
1495
       
 
       
		return

     

       
1496
       
 
       
	}

     

       
1497
       
 
       


     
···

       
1502
       
 
       


     

       
1503
       
 
       
	states, err := db.GetLabels(rp.db, db.FilterEq("subject", subject))

     

       
1504
       
 
       
	if err != nil {

     

       
1505
       
-
       
		log.Println("failed to build label state", err)

     

       
1506
       
 
       
		return

     

       
1507
       
 
       
	}

     

       
1508
       
 
       
	state := states[subject]

     
···

       
1649
       
 
       


     

       
1650
       
 
       
func (rp *Repo) DeleteRepo(w http.ResponseWriter, r *http.Request) {

     

       
1651
       
 
       
	user := rp.oauth.GetUser(r)

     

       
0
       
 
       

     

       
1652
       
 
       


     

       
1653
       
 
       
	noticeId := "operation-error"

     

       
1654
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
1655
       
 
       
	if err != nil {

     

       
1656
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
1657
       
 
       
		return

     

       
1658
       
 
       
	}

     

       
1659
       
 
       


     

       
1660
       
 
       
	// remove record from pds

     

       
1661
       
 
       
	atpClient, err := rp.oauth.AuthorizedClient(r)

     

       
1662
       
 
       
	if err != nil {

     

       
1663
       
-
       
		log.Println("failed to get authorized client", err)

     

       
1664
       
 
       
		return

     

       
1665
       
 
       
	}

     

       
1666
       
 
       
	_, err = comatproto.RepoDeleteRecord(r.Context(), atpClient, &comatproto.RepoDeleteRecord_Input{

     
···

       
1669
       
 
       
		Rkey:       f.Rkey,

     

       
1670
       
 
       
	})

     

       
1671
       
 
       
	if err != nil {

     

       
1672
       
-
       
		log.Printf("failed to delete record: %s", err)

     

       
1673
       
 
       
		rp.pages.Notice(w, noticeId, "Failed to delete repository from PDS.")

     

       
1674
       
 
       
		return

     

       
1675
       
 
       
	}

     

       
1676
       
-
       
	log.Println("removed repo record ", f.RepoAt().String())

     

       
1677
       
 
       


     

       
1678
       
 
       
	client, err := rp.oauth.ServiceClient(

     

       
1679
       
 
       
		r,

     
···

       
1682
       
 
       
		oauth.WithDev(rp.config.Core.Dev),

     

       
1683
       
 
       
	)

     

       
1684
       
 
       
	if err != nil {

     

       
1685
       
-
       
		log.Println("failed to connect to knot server:", err)

     

       
1686
       
 
       
		return

     

       
1687
       
 
       
	}

     

       
1688
       
 
       


     
···

       
1699
       
 
       
		rp.pages.Notice(w, noticeId, err.Error())

     

       
1700
       
 
       
		return

     

       
1701
       
 
       
	}

     

       
1702
       
-
       
	log.Println("deleted repo from knot")

     

       
1703
       
 
       


     

       
1704
       
 
       
	tx, err := rp.db.BeginTx(r.Context(), nil)

     

       
1705
       
 
       
	if err != nil {

     

       
1706
       
-
       
		log.Println("failed to start tx")

     

       
1707
       
 
       
		w.Write(fmt.Append(nil, "failed to add collaborator: ", err))

     

       
1708
       
 
       
		return

     

       
1709
       
 
       
	}

     
···

       
1711
       
 
       
		tx.Rollback()

     

       
1712
       
 
       
		err = rp.enforcer.E.LoadPolicy()

     

       
1713
       
 
       
		if err != nil {

     

       
1714
       
-
       
			log.Println("failed to rollback policies")

     

       
1715
       
 
       
		}

     

       
1716
       
 
       
	}()

     

       
1717
       
 
       


     
···

       
1725
       
 
       
		did := c[0]

     

       
1726
       
 
       
		rp.enforcer.RemoveCollaborator(did, f.Knot, f.DidSlashRepo())

     

       
1727
       
 
       
	}

     

       
1728
       
-
       
	log.Println("removed collaborators")

     

       
1729
       
 
       


     

       
1730
       
 
       
	// remove repo RBAC

     

       
1731
       
 
       
	err = rp.enforcer.RemoveRepo(f.OwnerDid(), f.Knot, f.DidSlashRepo())

     
···

       
1740
       
 
       
		rp.pages.Notice(w, noticeId, "Failed to update appview")

     

       
1741
       
 
       
		return

     

       
1742
       
 
       
	}

     

       
1743
       
-
       
	log.Println("removed repo from db")

     

       
1744
       
 
       


     

       
1745
       
 
       
	err = tx.Commit()

     

       
1746
       
 
       
	if err != nil {

     

       
1747
       
-
       
		log.Println("failed to commit changes", err)

     

       
1748
       
 
       
		http.Error(w, err.Error(), http.StatusInternalServerError)

     

       
1749
       
 
       
		return

     

       
1750
       
 
       
	}

     

       
1751
       
 
       


     

       
1752
       
 
       
	err = rp.enforcer.E.SavePolicy()

     

       
1753
       
 
       
	if err != nil {

     

       
1754
       
-
       
		log.Println("failed to update ACLs", err)

     

       
1755
       
 
       
		http.Error(w, err.Error(), http.StatusInternalServerError)

     

       
1756
       
 
       
		return

     

       
1757
       
 
       
	}

     
···

       
1760
       
 
       
}

     

       
1761
       
 
       


     

       
1762
       
 
       
func (rp *Repo) SetDefaultBranch(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1763
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
1764
       
 
       
	if err != nil {

     

       
1765
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
1766
       
 
       
		return

     

       
1767
       
 
       
	}

     

       
1768
       
 
       


     
···

       
1780
       
 
       
		oauth.WithDev(rp.config.Core.Dev),

     

       
1781
       
 
       
	)

     

       
1782
       
 
       
	if err != nil {

     

       
1783
       
-
       
		log.Println("failed to connect to knot server:", err)

     

       
1784
       
 
       
		rp.pages.Notice(w, noticeId, "Failed to connect to knot server.")

     

       
1785
       
 
       
		return

     

       
1786
       
 
       
	}

     
···

       
1794
       
 
       
		},

     

       
1795
       
 
       
	)

     

       
1796
       
 
       
	if err := xrpcclient.HandleXrpcErr(xe); err != nil {

     

       
1797
       
-
       
		log.Println("xrpc failed", "err", xe)

     

       
1798
       
 
       
		rp.pages.Notice(w, noticeId, err.Error())

     

       
1799
       
 
       
		return

     

       
1800
       
 
       
	}

     
···

       
1809
       
 
       


     

       
1810
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
1811
       
 
       
	if err != nil {

     

       
1812
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
1813
       
 
       
		return

     

       
1814
       
 
       
	}

     

       
1815
       
 
       


     

       
1816
       
 
       
	if f.Spindle == "" {

     

       
1817
       
-
       
		log.Println("empty spindle cannot add/rm secret", err)

     

       
1818
       
 
       
		return

     

       
1819
       
 
       
	}

     

       
1820
       
 
       


     
···

       
1831
       
 
       
		oauth.WithDev(rp.config.Core.Dev),

     

       
1832
       
 
       
	)

     

       
1833
       
 
       
	if err != nil {

     

       
1834
       
-
       
		log.Println("failed to create spindle client", err)

     

       
1835
       
 
       
		return

     

       
1836
       
 
       
	}

     

       
1837
       
 
       


     
···

       
1917
       
 
       
}

     

       
1918
       
 
       


     

       
1919
       
 
       
func (rp *Repo) generalSettings(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
1920
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
1921
       
 
       
	user := rp.oauth.GetUser(r)

     

       
1922
       
 
       


     
···

       
1932
       
 
       
	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       
1933
       
 
       
	xrpcBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       
1934
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
1935
       
-
       
		log.Println("failed to call XRPC repo.branches", xrpcerr)

     

       
1936
       
 
       
		rp.pages.Error503(w)

     

       
1937
       
 
       
		return

     

       
1938
       
 
       
	}

     

       
1939
       
 
       


     

       
1940
       
 
       
	var result types.RepoBranchesResponse

     

       
1941
       
 
       
	if err := json.Unmarshal(xrpcBytes, &result); err != nil {

     

       
1942
       
-
       
		log.Println("failed to decode XRPC response", err)

     

       
1943
       
 
       
		rp.pages.Error503(w)

     

       
1944
       
 
       
		return

     

       
1945
       
 
       
	}

     

       
1946
       
 
       


     

       
1947
       
 
       
	defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", models.DefaultLabelDefs()))

     

       
1948
       
 
       
	if err != nil {

     

       
1949
       
-
       
		log.Println("failed to fetch labels", err)

     

       
1950
       
 
       
		rp.pages.Error503(w)

     

       
1951
       
 
       
		return

     

       
1952
       
 
       
	}

     

       
1953
       
 
       


     

       
1954
       
 
       
	labels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", f.Repo.Labels))

     

       
1955
       
 
       
	if err != nil {

     

       
1956
       
-
       
		log.Println("failed to fetch labels", err)

     

       
1957
       
 
       
		rp.pages.Error503(w)

     

       
1958
       
 
       
		return

     

       
1959
       
 
       
	}

     
···

       
2001
       
 
       
}

     

       
2002
       
 
       


     

       
2003
       
 
       
func (rp *Repo) accessSettings(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2004
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
2005
       
 
       
	user := rp.oauth.GetUser(r)

     

       
2006
       
 
       


     

       
2007
       
 
       
	repoCollaborators, err := f.Collaborators(r.Context())

     

       
2008
       
 
       
	if err != nil {

     

       
2009
       
-
       
		log.Println("failed to get collaborators", err)

     

       
2010
       
 
       
	}

     

       
2011
       
 
       


     

       
2012
       
 
       
	rp.pages.RepoAccessSettings(w, pages.RepoAccessSettingsParams{

     
···

       
2019
       
 
       
}

     

       
2020
       
 
       


     

       
2021
       
 
       
func (rp *Repo) pipelineSettings(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2022
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
2023
       
 
       
	user := rp.oauth.GetUser(r)

     

       
2024
       
 
       


     

       
2025
       
 
       
	// all spindles that the repo owner is a member of

     

       
2026
       
 
       
	spindles, err := rp.enforcer.GetSpindlesForUser(f.OwnerDid())

     

       
2027
       
 
       
	if err != nil {

     

       
2028
       
-
       
		log.Println("failed to fetch spindles", err)

     

       
2029
       
 
       
		return

     

       
2030
       
 
       
	}

     

       
2031
       
 
       


     
···

       
2038
       
 
       
			oauth.WithExp(60),

     

       
2039
       
 
       
			oauth.WithDev(rp.config.Core.Dev),

     

       
2040
       
 
       
		); err != nil {

     

       
2041
       
-
       
			log.Println("failed to create spindle client", err)

     

       
2042
       
 
       
		} else if resp, err := tangled.RepoListSecrets(r.Context(), spindleClient, f.RepoAt().String()); err != nil {

     

       
2043
       
-
       
			log.Println("failed to fetch secrets", err)

     

       
2044
       
 
       
		} else {

     

       
2045
       
 
       
			secrets = resp.Secrets

     

       
2046
       
 
       
		}

     
···

       
2080
       
 
       
}

     

       
2081
       
 
       


     

       
2082
       
 
       
func (rp *Repo) SyncRepoFork(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2083
       
 
       
	ref := chi.URLParam(r, "ref")

     

       
2084
       
 
       
	ref, _ = url.PathUnescape(ref)

     

       
2085
       
 
       


     

       
2086
       
 
       
	user := rp.oauth.GetUser(r)

     

       
2087
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
2088
       
 
       
	if err != nil {

     

       
2089
       
-
       
		log.Printf("failed to resolve source repo: %v", err)

     

       
2090
       
 
       
		return

     

       
2091
       
 
       
	}

     

       
2092
       
 
       


     
···

       
2130
       
 
       
}

     

       
2131
       
 
       


     

       
2132
       
 
       
func (rp *Repo) ForkRepo(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2133
       
 
       
	user := rp.oauth.GetUser(r)

     

       
2134
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
2135
       
 
       
	if err != nil {

     

       
2136
       
-
       
		log.Printf("failed to resolve source repo: %v", err)

     

       
2137
       
 
       
		return

     

       
2138
       
 
       
	}

     

       
2139
       
 
       


     
···

       
2184
       
 
       
		)

     

       
2185
       
 
       
		if err != nil {

     

       
2186
       
 
       
			if !errors.Is(err, sql.ErrNoRows) {

     

       
2187
       
-
       
				log.Println("error fetching existing repo from db", "err", err)

     

       
2188
       
 
       
				rp.pages.Notice(w, "repo", "Failed to fork this repository. Try again later.")

     

       
2189
       
 
       
				return

     

       
2190
       
 
       
			}

     
···

       
2299
       
 
       


     

       
2300
       
 
       
		err = db.AddRepo(tx, repo)

     

       
2301
       
 
       
		if err != nil {

     

       
2302
       
-
       
			log.Println(err)

     

       
2303
       
 
       
			rp.pages.Notice(w, "repo", "Failed to save repository information.")

     

       
2304
       
 
       
			return

     

       
2305
       
 
       
		}

     
···

       
2308
       
 
       
		p, _ := securejoin.SecureJoin(user.Did, forkName)

     

       
2309
       
 
       
		err = rp.enforcer.AddRepo(user.Did, targetKnot, p)

     

       
2310
       
 
       
		if err != nil {

     

       
2311
       
-
       
			log.Println(err)

     

       
2312
       
 
       
			rp.pages.Notice(w, "repo", "Failed to set up repository permissions.")

     

       
2313
       
 
       
			return

     

       
2314
       
 
       
		}

     

       
2315
       
 
       


     

       
2316
       
 
       
		err = tx.Commit()

     

       
2317
       
 
       
		if err != nil {

     

       
2318
       
-
       
			log.Println("failed to commit changes", err)

     

       
2319
       
 
       
			http.Error(w, err.Error(), http.StatusInternalServerError)

     

       
2320
       
 
       
			return

     

       
2321
       
 
       
		}

     

       
2322
       
 
       


     

       
2323
       
 
       
		err = rp.enforcer.E.SavePolicy()

     

       
2324
       
 
       
		if err != nil {

     

       
2325
       
-
       
			log.Println("failed to update ACLs", err)

     

       
2326
       
 
       
			http.Error(w, err.Error(), http.StatusInternalServerError)

     

       
2327
       
 
       
			return

     

       
2328
       
 
       
		}

     
···

       
2358
       
 
       
}

     

       
2359
       
 
       


     

       
2360
       
 
       
func (rp *Repo) RepoCompareNew(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2361
       
 
       
	user := rp.oauth.GetUser(r)

     

       
2362
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
2363
       
 
       
	if err != nil {

     

       
2364
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
2365
       
 
       
		return

     

       
2366
       
 
       
	}

     

       
2367
       
 
       


     
···

       
2377
       
 
       
	repo := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       
2378
       
 
       
	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       
2379
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
2380
       
-
       
		log.Println("failed to call XRPC repo.branches", xrpcerr)

     

       
2381
       
 
       
		rp.pages.Error503(w)

     

       
2382
       
 
       
		return

     

       
2383
       
 
       
	}

     

       
2384
       
 
       


     

       
2385
       
 
       
	var branchResult types.RepoBranchesResponse

     

       
2386
       
 
       
	if err := json.Unmarshal(branchBytes, &branchResult); err != nil {

     

       
2387
       
-
       
		log.Println("failed to decode XRPC branches response", err)

     

       
2388
       
 
       
		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")

     

       
2389
       
 
       
		return

     

       
2390
       
 
       
	}

     
···

       
2414
       
 
       


     

       
2415
       
 
       
	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       
2416
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
2417
       
-
       
		log.Println("failed to call XRPC repo.tags", xrpcerr)

     

       
2418
       
 
       
		rp.pages.Error503(w)

     

       
2419
       
 
       
		return

     

       
2420
       
 
       
	}

     

       
2421
       
 
       


     

       
2422
       
 
       
	var tags types.RepoTagsResponse

     

       
2423
       
 
       
	if err := json.Unmarshal(tagBytes, &tags); err != nil {

     

       
2424
       
-
       
		log.Println("failed to decode XRPC tags response", err)

     

       
2425
       
 
       
		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")

     

       
2426
       
 
       
		return

     

       
2427
       
 
       
	}

     
···

       
2439
       
 
       
}

     

       
2440
       
 
       


     

       
2441
       
 
       
func (rp *Repo) RepoCompare(w http.ResponseWriter, r *http.Request) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2442
       
 
       
	user := rp.oauth.GetUser(r)

     

       
2443
       
 
       
	f, err := rp.repoResolver.Resolve(r)

     

       
2444
       
 
       
	if err != nil {

     

       
2445
       
-
       
		log.Println("failed to get repo and knot", err)

     

       
2446
       
 
       
		return

     

       
2447
       
 
       
	}

     

       
2448
       
 
       


     
···

       
2469
       
 
       
	head, _ = url.PathUnescape(head)

     

       
2470
       
 
       


     

       
2471
       
 
       
	if base == "" || head == "" {

     

       
2472
       
-
       
		log.Printf("invalid comparison")

     

       
2473
       
 
       
		rp.pages.Error404(w)

     

       
2474
       
 
       
		return

     

       
2475
       
 
       
	}

     
···

       
2487
       
 
       


     

       
2488
       
 
       
	branchBytes, err := tangled.RepoBranches(r.Context(), xrpcc, "", 0, repo)

     

       
2489
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
2490
       
-
       
		log.Println("failed to call XRPC repo.branches", xrpcerr)

     

       
2491
       
 
       
		rp.pages.Error503(w)

     

       
2492
       
 
       
		return

     

       
2493
       
 
       
	}

     

       
2494
       
 
       


     

       
2495
       
 
       
	var branches types.RepoBranchesResponse

     

       
2496
       
 
       
	if err := json.Unmarshal(branchBytes, &branches); err != nil {

     

       
2497
       
-
       
		log.Println("failed to decode XRPC branches response", err)

     

       
2498
       
 
       
		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")

     

       
2499
       
 
       
		return

     

       
2500
       
 
       
	}

     

       
2501
       
 
       


     

       
2502
       
 
       
	tagBytes, err := tangled.RepoTags(r.Context(), xrpcc, "", 0, repo)

     

       
2503
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
2504
       
-
       
		log.Println("failed to call XRPC repo.tags", xrpcerr)

     

       
2505
       
 
       
		rp.pages.Error503(w)

     

       
2506
       
 
       
		return

     

       
2507
       
 
       
	}

     

       
2508
       
 
       


     

       
2509
       
 
       
	var tags types.RepoTagsResponse

     

       
2510
       
 
       
	if err := json.Unmarshal(tagBytes, &tags); err != nil {

     

       
2511
       
-
       
		log.Println("failed to decode XRPC tags response", err)

     

       
2512
       
 
       
		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")

     

       
2513
       
 
       
		return

     

       
2514
       
 
       
	}

     

       
2515
       
 
       


     

       
2516
       
 
       
	compareBytes, err := tangled.RepoCompare(r.Context(), xrpcc, repo, base, head)

     

       
2517
       
 
       
	if xrpcerr := xrpcclient.HandleXrpcErr(err); xrpcerr != nil {

     

       
2518
       
-
       
		log.Println("failed to call XRPC repo.compare", xrpcerr)

     

       
2519
       
 
       
		rp.pages.Error503(w)

     

       
2520
       
 
       
		return

     

       
2521
       
 
       
	}

     

       
2522
       
 
       


     

       
2523
       
 
       
	var formatPatch types.RepoFormatPatchResponse

     

       
2524
       
 
       
	if err := json.Unmarshal(compareBytes, &formatPatch); err != nil {

     

       
2525
       
-
       
		log.Println("failed to decode XRPC compare response", err)

     

       
2526
       
 
       
		rp.pages.Notice(w, "compare-error", "Failed to produce comparison. Try again later.")

     

       
2527
       
 
       
		return

     

       
2528
       
 
       
	}