appview: fixes for xrpc migration

Signed-off-by: oppiliappan <[e-mail]>

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

···
     <div class="col-span-1 md:col-span-3 flex flex-col gap-6 p-2">
       {{ template "branchSettings" . }}
       {{ template "deleteRepo" . }}
+      <div id="operation-error" class="text-red-500 dark:text-red-400"></div>
     </div>
   </section>
 {{ end }}
···
         unless you specify a different branch.
       </p>
     </div>
-    <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">
+    <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">
       <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">
         <option value="" disabled selected >
           Choose a default branch
···
       <button 
         class="btn group text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300 flex gap-2 items-center"  
         type="button"
+        hx-swap="none"
         hx-delete="/{{ $.RepoInfo.FullName }}/settings/delete"
         hx-confirm="Are you sure you want to delete {{ $.RepoInfo.FullName }}?">
           {{ i "trash-2" "size-4" }}

appview/pulls/pulls.go

···
 	"tangled.sh/tangled.sh/core/appview/pages"
 	"tangled.sh/tangled.sh/core/appview/pages/markup"
 	"tangled.sh/tangled.sh/core/appview/reporesolver"
+	"tangled.sh/tangled.sh/core/appview/xrpcclient"
 	"tangled.sh/tangled.sh/core/idresolver"
 	"tangled.sh/tangled.sh/core/knotclient"
 	"tangled.sh/tangled.sh/core/patchutil"
···
 	"github.com/bluekeyes/go-gitdiff/gitdiff"
 	comatproto "github.com/bluesky-social/indigo/api/atproto"
 	lexutil "github.com/bluesky-social/indigo/lex/util"
+	indigoxrpc "github.com/bluesky-social/indigo/xrpc"
 	"github.com/go-chi/chi/v5"
 	"github.com/google/uuid"
 )
···
 		return types.MergeCheckResponse{}
 	}
 
-	client, err := s.oauth.ServiceClient(
-		r,
-		oauth.WithService(f.Knot),
-		oauth.WithLxm(tangled.RepoMergeCheckNSID),
-		oauth.WithDev(s.config.Core.Dev),
-	)
-	if err != nil {
-		log.Printf("failed to connect to knot server: %v", err)
-		return types.MergeCheckResponse{
-			Error: "failed to check merge status: could not connect to knot server",
-		}
+	scheme := "https"
+	if s.config.Core.Dev {
+		scheme = "http"
+	}
+	host := fmt.Sprintf("%s://%s", scheme, f.Knot)
+
+	xrpcc := indigoxrpc.Client{
+		Host: host,
 	}
 
 	patch := pull.LatestPatch()
···
 			Repo:      fork.RepoAt().String(),
 		},
 	)
-	if err != nil {
-		xe, parseErr := xrpcerr.Unmarshal(err.Error())
-		if parseErr != nil {
-			log.Printf("failed to create hidden ref: %v", err)
-			s.pages.Notice(w, "pull", "Failed to create pull request. Try again later.")
-		} else {
-			log.Printf("failed to create hidden ref: %s", xe.Error())
-			if xe.Tag == "AccessControl" {
-				s.pages.Notice(w, "pull", "Branch based pull requests are not supported on this knot.")
-			} else {
-				s.pages.Notice(w, "pull", fmt.Sprintf("Failed to create pull request: %s", xe.Message))
-			}
-		}
+	if err := xrpcclient.HandleXrpcErr(err); err != nil {
+		s.pages.Notice(w, "pull", err.Error())
 		return
 	}
 
···
 			Repo:      forkRepo.RepoAt().String(),
 		},
 	)
-	if err != nil || !resp.Success {
-		if err != nil {
-			log.Printf("failed to update tracking branch: %s", err)
-		} else {
-			log.Printf("failed to update tracking branch: success=false")
-		}
-		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")
+	if err := xrpcclient.HandleXrpcErr(err); err != nil {
+		s.pages.Notice(w, "resubmit-error", err.Error())
+		return
+	}
+	if !resp.Success {
+		log.Println("Failed to update tracking ref.", "err", resp.Error)
+		s.pages.Notice(w, "resubmit-error", "Failed to update tracking ref.")
 		return
 	}
 
···
 	}
 
 	patch := pullsToMerge.CombinedPatch()
-
-	client, err := s.oauth.ServiceClient(
-		r,
-		oauth.WithService(f.Knot),
-		oauth.WithLxm(tangled.RepoMergeNSID),
-		oauth.WithDev(s.config.Core.Dev),
-	)
-	if err != nil {
-		log.Printf("failed to connect to knot server: %v", err)
-		s.pages.Notice(w, "pull-merge-error", "Failed to merge pull request. Try again later.")
-		return
-	}
 
 	ident, err := s.idResolver.ResolveIdent(r.Context(), pull.OwnerDid)
 	if err != nil {

appview/repo/repo.go

···
 func (rp *Repo) DeleteRepo(w http.ResponseWriter, r *http.Request) {
 	user := rp.oauth.GetUser(r)
 
+	noticeId := "operation-error"
 	f, err := rp.repoResolver.Resolve(r)
 	if err != nil {
 		log.Println("failed to get repo and knot", err)
···
 	})
 	if err != nil {
 		log.Printf("failed to delete record: %s", err)
-		rp.pages.Notice(w, "settings-delete", "Failed to delete repository from PDS.")
+		rp.pages.Notice(w, noticeId, "Failed to delete repository from PDS.")
 		return
 	}
 	log.Println("removed repo record ", f.RepoAt().String())
···
 			Name: f.Name,
 		},
 	)
-	if err != nil {
-		xe, parseErr := xrpcerr.Unmarshal(err.Error())
-		if parseErr != nil {
-			log.Printf("failed to delete repo from knot %s: %s", f.Knot, err)
-		} else {
-			log.Printf("failed to delete repo from knot %s: %s", f.Knot, xe.Error())
-		}
-		// Continue anyway since we want to clean up local state
-	} else {
-		log.Println("removed repo from knot ", f.Knot)
+	if err := xrpcclient.HandleXrpcErr(err); err != nil {
+		rp.pages.Notice(w, noticeId, err.Error())
+		return
 	}
+	log.Println("deleted repo from knot")
 
 	tx, err := rp.db.BeginTx(r.Context(), nil)
 	if err != nil {
···
 	// remove collaborator RBAC
 	repoCollaborators, err := rp.enforcer.E.GetImplicitUsersForResourceByDomain(f.DidSlashRepo(), f.Knot)
 	if err != nil {
-		rp.pages.Notice(w, "settings-delete", "Failed to remove collaborators")
+		rp.pages.Notice(w, noticeId, "Failed to remove collaborators")
 		return
 	}
 	for _, c := range repoCollaborators {
···
 	// remove repo RBAC
 	err = rp.enforcer.RemoveRepo(f.OwnerDid(), f.Knot, f.DidSlashRepo())
 	if err != nil {
-		rp.pages.Notice(w, "settings-delete", "Failed to update RBAC rules")
+		rp.pages.Notice(w, noticeId, "Failed to update RBAC rules")
 		return
 	}
 
 	// remove repo from db
 	err = db.RemoveRepo(tx, f.OwnerDid(), f.Name)
 	if err != nil {
-		rp.pages.Notice(w, "settings-delete", "Failed to update appview")
+		rp.pages.Notice(w, noticeId, "Failed to update appview")
 		return
 	}
 	log.Println("removed repo from db")
···
 		return
 	}
 
+	noticeId := "operation-error"
 	branch := r.FormValue("branch")
 	if branch == "" {
 		http.Error(w, "malformed form", http.StatusBadRequest)
···
 		return
 	}
 
-	w.Write(fmt.Append(nil, "default branch set to: ", branch))
+	rp.pages.HxRefresh(w)
 }
 
 func (rp *Repo) Secrets(w http.ResponseWriter, r *http.Request) {
···
 				Branch: ref,
 			},
 		)
-		if err != nil {
-			xe, parseErr := xrpcerr.Unmarshal(err.Error())
-			if parseErr != nil {
-				log.Printf("failed to sync repository fork: %s", err)
-				rp.pages.Notice(w, "repo", "Failed to sync repository fork.")
-			} else {
-				log.Printf("failed to sync repository fork: %s", xe.Error())
-				rp.pages.Notice(w, "repo", fmt.Sprintf("Failed to sync repository fork: %s", xe.Message))
-			}
+		if err := xrpcclient.HandleXrpcErr(err); err != nil {
+			rp.pages.Notice(w, "repo", err.Error())
 			return
 		}