commit d73d335bf23ec2c07c5d453936b0595d07423a4a · veryroundbird.house/core

+3 -1

appview/pages/templates/repo/settings/general.html

···

       8
       8
        
           <div class="col-span-1 md:col-span-3 flex flex-col gap-6 p-2">

     

       9
       9
        
             {{ template "branchSettings" . }}

     

       10
       10
        
             {{ template "deleteRepo" . }}

     

       11
       11
       +
             <div id="operation-error" class="text-red-500 dark:text-red-400"></div>

     

       11
       12
        
           </div>

     

       12
       13
        
         </section>

     

       13
       14
        
       {{ end }}

     
···

       22
       23
        
               unless you specify a different branch.

     

       23
       24
        
             </p>

     

       24
       25
        
           </div>

     

       25
       25
       -
           <form hx-put="/{{ $.RepoInfo.FullName }}/settings/branches/default" class="col-span-1 md:col-span-1 md:justify-self-end group flex gap-2 items-stretch">

     

       26
       26
       +
           <form hx-put="/{{ $.RepoInfo.FullName }}/settings/branches/default" hx-swap="none" class="col-span-1 md:col-span-1 md:justify-self-end group flex gap-2 items-stretch">

     

       26
       27
        
             <select id="branch" name="branch" required class="p-1 max-w-64 border border-gray-200 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-700">

     

       27
       28
        
               <option value="" disabled selected >

     

       28
       29
        
                 Choose a default branch

     
···

       54
       55
        
             <button 

     

       55
       56
        
               class="btn group text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 flex gap-2 items-center"  

     

       56
       57
        
               type="button"

     

       58
       58
       +
               hx-swap="none"

     

       57
       59
        
               hx-delete="/{{ $.RepoInfo.FullName }}/settings/delete"

     

       58
       60
        
               hx-confirm="Are you sure you want to delete {{ $.RepoInfo.FullName }}?">

     

       59
       61
        
                 {{ i "trash-2" "size-4" }}

+19 -43

appview/pulls/pulls.go

···

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

     

       20
       20
        
       	"tangled.sh/tangled.sh/core/appview/pages/markup"

     

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

     

       22
       22
       +
       	"tangled.sh/tangled.sh/core/appview/xrpcclient"

     

       22
       23
        
       	"tangled.sh/tangled.sh/core/idresolver"

     

       23
       24
        
       	"tangled.sh/tangled.sh/core/knotclient"

     

       24
       25
        
       	"tangled.sh/tangled.sh/core/patchutil"

     
···

       28
       29
        
       	"github.com/bluekeyes/go-gitdiff/gitdiff"

     

       29
       30
        
       	comatproto "github.com/bluesky-social/indigo/api/atproto"

     

       30
       31
        
       	lexutil "github.com/bluesky-social/indigo/lex/util"

     

       32
       32
       +
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     

       31
       33
        
       	"github.com/go-chi/chi/v5"

     

       32
       34
        
       	"github.com/google/uuid"

     

       33
       35
        
       )

     
···

       218
       220
        
       		return types.MergeCheckResponse{}

     

       219
       221
        
       	}

     

       220
       222
        
       

     

       221
       221
       -
       	client, err := s.oauth.ServiceClient(

     

       222
       222
       -
       		r,

     

       223
       223
       -
       		oauth.WithService(f.Knot),

     

       224
       224
       -
       		oauth.WithLxm(tangled.RepoMergeCheckNSID),

     

       225
       225
       -
       		oauth.WithDev(s.config.Core.Dev),

     

       226
       226
       -
       	)

     

       227
       227
       -
       	if err != nil {

     

       228
       228
       -
       		log.Printf("failed to connect to knot server: %v", err)

     

       229
       229
       -
       		return types.MergeCheckResponse{

     

       230
       230
       -
       			Error: "failed to check merge status: could not connect to knot server",

     

       231
       231
       -
       		}

     

       223
       223
       +
       	scheme := "https"

     

       224
       224
       +
       	if s.config.Core.Dev {

     

       225
       225
       +
       		scheme = "http"

     

       226
       226
       +
       	}

     

       227
       227
       +
       	host := fmt.Sprintf("%s://%s", scheme, f.Knot)

     

       228
       228
       +
       

     

       229
       229
       +
       	xrpcc := indigoxrpc.Client{

     

       230
       230
       +
       		Host: host,

     

       232
       231
        
       	}

     

       233
       232
        
       

     

       234
       233
        
       	patch := pull.LatestPatch()

     
···

       893
       892
        
       			Repo:      fork.RepoAt().String(),

     

       894
       893
        
       		},

     

       895
       894
        
       	)

     

       896
       896
       -
       	if err != nil {

     

       897
       897
       -
       		xe, parseErr := xrpcerr.Unmarshal(err.Error())

     

       898
       898
       -
       		if parseErr != nil {

     

       899
       899
       -
       			log.Printf("failed to create hidden ref: %v", err)

     

       900
       900
       -
       			s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")

     

       901
       901
       -
       		} else {

     

       902
       902
       -
       			log.Printf("failed to create hidden ref: %s", xe.Error())

     

       903
       903
       -
       			if xe.Tag == "AccessControl" {

     

       904
       904
       -
       				s.pages.Notice(w, "pull", "Branch based pull requests are not supported on this knot.")

     

       905
       905
       -
       			} else {

     

       906
       906
       -
       				s.pages.Notice(w, "pull", fmt.Sprintf("Failed to create pull request: %s", xe.Message))

     

       907
       907
       -
       			}

     

       908
       908
       -
       		}

     

       895
       895
       +
       	if err := xrpcclient.HandleXrpcErr(err); err != nil {

     

       896
       896
       +
       		s.pages.Notice(w, "pull", err.Error())

     

       909
       897
        
       		return

     

       910
       898
        
       	}

     

       911
       899
        
       

     
···

       1501
       1489
        
       			Repo:      forkRepo.RepoAt().String(),

     

       1502
       1490
        
       		},

     

       1503
       1491
        
       	)

     

       1504
       1504
       -
       	if err != nil || !resp.Success {

     

       1505
       1505
       -
       		if err != nil {

     

       1506
       1506
       -
       			log.Printf("failed to update tracking branch: %s", err)

     

       1507
       1507
       -
       		} else {

     

       1508
       1508
       -
       			log.Printf("failed to update tracking branch: success=false")

     

       1509
       1509
       -
       		}

     

       1510
       1510
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     

       1492
       1492
       +
       	if err := xrpcclient.HandleXrpcErr(err); err != nil {

     

       1493
       1493
       +
       		s.pages.Notice(w, "resubmit-error", err.Error())

     

       1494
       1494
       +
       		return

     

       1495
       1495
       +
       	}

     

       1496
       1496
       +
       	if !resp.Success {

     

       1497
       1497
       +
       		log.Println("Failed to update tracking ref.", "err", resp.Error)

     

       1498
       1498
       +
       		s.pages.Notice(w, "resubmit-error", "Failed to update tracking ref.")

     

       1511
       1499
        
       		return

     

       1512
       1500
        
       	}

     

       1513
       1501
        
       

     
···

       1932
       1920
        
       	}

     

       1933
       1921
        
       

     

       1934
       1922
        
       	patch := pullsToMerge.CombinedPatch()

     

       1935
       1935
       -
       

     

       1936
       1936
       -
       	client, err := s.oauth.ServiceClient(

     

       1937
       1937
       -
       		r,

     

       1938
       1938
       -
       		oauth.WithService(f.Knot),

     

       1939
       1939
       -
       		oauth.WithLxm(tangled.RepoMergeNSID),

     

       1940
       1940
       -
       		oauth.WithDev(s.config.Core.Dev),

     

       1941
       1941
       -
       	)

     

       1942
       1942
       -
       	if err != nil {

     

       1943
       1943
       -
       		log.Printf("failed to connect to knot server: %v", err)

     

       1944
       1944
       -
       		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")

     

       1945
       1945
       -
       		return

     

       1946
       1946
       -
       	}

     

       1947
       1923
        
       

     

       1948
       1924
        
       	ident, err := s.idResolver.ResolveIdent(r.Context(), pull.OwnerDid)

     

       1949
       1925
        
       	if err != nil {

+13 -24

appview/repo/repo.go

···

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

     

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

     

       932
       932
        
       

     

       933
       933
       +
       	noticeId := "operation-error"

     

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

     

       934
       935
        
       	if err != nil {

     

       935
       936
        
       		log.Println("failed to get repo and knot", err)

     
···

       949
       950
        
       	})

     

       950
       951
        
       	if err != nil {

     

       951
       952
        
       		log.Printf("failed to delete record: %s", err)

     

       952
       952
       -
       		rp.pages.Notice(w, "settings-delete", "Failed to delete repository from PDS.")

     

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

     

       953
       954
        
       		return

     

       954
       955
        
       	}

     

       955
       956
        
       	log.Println("removed repo record ", f.RepoAt().String())

     
···

       973
       974
        
       			Name: f.Name,

     

       974
       975
        
       		},

     

       975
       976
        
       	)

     

       976
       976
       -
       	if err != nil {

     

       977
       977
       -
       		xe, parseErr := xrpcerr.Unmarshal(err.Error())

     

       978
       978
       -
       		if parseErr != nil {

     

       979
       979
       -
       			log.Printf("failed to delete repo from knot %s: %s", f.Knot, err)

     

       980
       980
       -
       		} else {

     

       981
       981
       -
       			log.Printf("failed to delete repo from knot %s: %s", f.Knot, xe.Error())

     

       982
       982
       -
       		}

     

       983
       983
       -
       		// Continue anyway since we want to clean up local state

     

       984
       984
       -
       	} else {

     

       985
       985
       -
       		log.Println("removed repo from knot ", f.Knot)

     

       977
       977
       +
       	if err := xrpcclient.HandleXrpcErr(err); err != nil {

     

       978
       978
       +
       		rp.pages.Notice(w, noticeId, err.Error())

     

       979
       979
       +
       		return

     

       986
       980
        
       	}

     

       981
       981
       +
       	log.Println("deleted repo from knot")

     

       987
       982
        
       

     

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

     

       989
       984
        
       	if err != nil {

     
···

       1002
       997
        
       	// remove collaborator RBAC

     

       1003
       998
        
       	repoCollaborators, err := rp.enforcer.E.GetImplicitUsersForResourceByDomain(f.DidSlashRepo(), f.Knot)

     

       1004
       999
        
       	if err != nil {

     

       1005
       1005
       -
       		rp.pages.Notice(w, "settings-delete", "Failed to remove collaborators")

     

       1000
       1000
       +
       		rp.pages.Notice(w, noticeId, "Failed to remove collaborators")

     

       1006
       1001
        
       		return

     

       1007
       1002
        
       	}

     

       1008
       1003
        
       	for _, c := range repoCollaborators {

     
···

       1014
       1009
        
       	// remove repo RBAC

     

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

     

       1016
       1011
        
       	if err != nil {

     

       1017
       1017
       -
       		rp.pages.Notice(w, "settings-delete", "Failed to update RBAC rules")

     

       1012
       1012
       +
       		rp.pages.Notice(w, noticeId, "Failed to update RBAC rules")

     

       1018
       1013
        
       		return

     

       1019
       1014
        
       	}

     

       1020
       1015
        
       

     

       1021
       1016
        
       	// remove repo from db

     

       1022
       1017
        
       	err = db.RemoveRepo(tx, f.OwnerDid(), f.Name)

     

       1023
       1018
        
       	if err != nil {

     

       1024
       1024
       -
       		rp.pages.Notice(w, "settings-delete", "Failed to update appview")

     

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

     

       1025
       1020
        
       		return

     

       1026
       1021
        
       	}

     

       1027
       1022
        
       	log.Println("removed repo from db")

     
···

       1050
       1045
        
       		return

     

       1051
       1046
        
       	}

     

       1052
       1047
        
       

     

       1048
       1048
       +
       	noticeId := "operation-error"

     

       1053
       1049
        
       	branch := r.FormValue("branch")

     

       1054
       1050
        
       	if branch == "" {

     

       1055
       1051
        
       		http.Error(w, "malformed form", http.StatusBadRequest)

     
···

       1082
       1078
        
       		return

     

       1083
       1079
        
       	}

     

       1084
       1080
        
       

     

       1085
       1085
       -
       	w.Write(fmt.Append(nil, "default branch set to: ", branch))

     

       1081
       1081
       +
       	rp.pages.HxRefresh(w)

     

       1086
       1082
        
       }

     

       1087
       1083
        
       

     

       1088
       1084
        
       func (rp *Repo) Secrets(w http.ResponseWriter, r *http.Request) {

     
···

       1344
       1340
        
       				Branch: ref,

     

       1345
       1341
        
       			},

     

       1346
       1342
        
       		)

     

       1347
       1347
       -
       		if err != nil {

     

       1348
       1348
       -
       			xe, parseErr := xrpcerr.Unmarshal(err.Error())

     

       1349
       1349
       -
       			if parseErr != nil {

     

       1350
       1350
       -
       				log.Printf("failed to sync repository fork: %s", err)

     

       1351
       1351
       -
       				rp.pages.Notice(w, "repo", "Failed to sync repository fork.")

     

       1352
       1352
       -
       			} else {

     

       1353
       1353
       -
       				log.Printf("failed to sync repository fork: %s", xe.Error())

     

       1354
       1354
       -
       				rp.pages.Notice(w, "repo", fmt.Sprintf("Failed to sync repository fork: %s", xe.Message))

     

       1355
       1355
       -
       			}

     

       1343
       1343
       +
       		if err := xrpcclient.HandleXrpcErr(err); err != nil {

     

       1344
       1344
       +
       			rp.pages.Notice(w, "repo", err.Error())

     

       1356
       1345
        
       			return

     

       1357
       1346
        
       		}

     

       1358
       1347