appview: allow default knot to be saved as a preference and then used when creating a new repo

Signed-off-by: Will Andrews <[e-mail]>

appview/db/db.go

···
 			unique (from_at, to_at)
 		);
 
+		create table if not exists knot_preferences (
+			id integer primary key autoincrement,
+			user_did text not null unique,
+			default_knot text
+		);
+
 		create table if not exists migrations (
 			id integer primary key autoincrement,
 			name text unique
···
 		// transfer data, constructing pull_at from pulls table
 		_, err = tx.Exec(`
 		insert into pull_submissions_new (id, pull_at, round_number, patch, created)
-		select 
+		select
 			ps.id,
 			'at://' || p.owner_did || '/sh.tangled.repo.pull/' || p.rkey,
 			ps.round_number,

appview/db/preferences.go

···
+package db
+
+import (
+	"database/sql"
+
+	"tangled.org/core/appview/models"
+)
+
+func GetKnotPreference(e Execer, did string) (*models.KnotPreference, error) {
+	var knotPreference models.KnotPreference
+
+	err := e.QueryRow(
+		`select id, user_did, default_knot from knot_preferences where user_did = ?`,
+		did,
+	).Scan(&knotPreference.ID, &knotPreference.Did, &knotPreference.DefaultKnot)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	return &knotPreference, nil
+}
+
+func UpsertKnotPreference(e Execer, did, defaultKnot string) error {
+	_, err := e.Exec(
+		`insert or replace into knot_preferences (
+			user_did,
+			default_knot
+		)
+		values (?, ?)`,
+		did,
+		defaultKnot,
+	)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

appview/db/profile.go

···
 			description,
 			include_bluesky,
 			location,
-			pronouns
+			pronouns,
+			default_knot
 		)
 		values (?, ?, ?, ?, ?)`,
 		profile.Did,
···
 func GetProfile(e Execer, did string) (*models.Profile, error) {
 	var profile models.Profile
 	var pronouns sql.Null[string]
-
 	profile.Did = did
 
 	includeBluesky := 0

appview/knots/knots.go

···
 		return
 	}
 
+	availableKnots, err := k.Enforcer.GetKnotsForUser(user.Did())
+	if err != nil {
+		k.Logger.Error("failed to fetch available knots for user", "err", err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	defaultKnot := ""
+	knotPrefence, err := db.GetKnotPreference(k.Db, user.Did())
+	if err != nil {
+		k.Logger.Warn("gettings users knot preferences", "error", err)
+	}
+	if knotPrefence != nil {
+		defaultKnot = knotPrefence.DefaultKnot
+	}
+
 	k.Pages.Knots(w, pages.KnotsParams{
-		LoggedInUser:  user,
-		Registrations: registrations,
-		Tabs:          knotsTabs,
-		Tab:           "knots",
+		LoggedInUser:   user,
+		Registrations:  registrations,
+		Tabs:           knotsTabs,
+		Tab:            "knots",
+		AvailableKnots: availableKnots,
+		DefaultKnot:    defaultKnot,
 	})
 }
 

appview/models/preferences.go

···
+package models
+
+type KnotPreference struct {
+	ID          int
+	Did         string
+	DefaultKnot string
+}

appview/pages/pages.go

···
 }
 
 type KnotsParams struct {
-	LoggedInUser  *oauth.MultiAccountUser
-	Registrations []models.Registration
-	Tabs          []map[string]any
-	Tab           string
+	LoggedInUser   *oauth.MultiAccountUser
+	Registrations  []models.Registration
+	Tabs           []map[string]any
+	Tab            string
+	AvailableKnots []string
+	DefaultKnot    string
 }
 
 func (p *Pages) Knots(w io.Writer, params KnotsParams) error {
···
 type NewRepoParams struct {
 	LoggedInUser *oauth.MultiAccountUser
 	Knots        []string
+	DefaultKnot  string
 }
 
 func (p *Pages) NewRepo(w io.Writer, params NewRepoParams) error {
···
 	LoggedInUser *oauth.MultiAccountUser
 	Knots        []string
 	RepoInfo     repoinfo.RepoInfo
+	DefaultKnot  string
 }
 
 func (p *Pages) ForkRepo(w io.Writer, params ForkRepoParams) error {

appview/pages/templates/knots/index.html

···
   <div class="flex flex-col gap-6">
     {{ block "list" . }} {{ end }}
     {{ block "register" . }} {{ end }}
+    {{ block "default-knot" . }} {{ end }}
   </div>
 </section>
 {{ end }}
···
     </div>
     <div id="operation-error" class="text-red-500 dark:text-red-400"></div>
   </section>
+{{ end }}
+
+{{ define "default-knot" }}
+<section class="rounded w-full flex flex-col gap-2">
+  <h2 class="text-sm font-bold py-2 uppercase dark:text-gray-300">default knot</h2>
+  <form hx-post="/profile/default-knot" class="col-span-1 md:col-span-1 md:justify-self-end group flex gap-2 items-stretch">
+    <select
+      id="default-knot"
+      name="default-knot"
+      required
+      class="p-1 max-w-64 border border-gray-200 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-700">
+      {{/* For some reason, we can't use an empty string in a <select> in all scenarios unless it is preceded by a disabled select?? No idea, could just be a Firefox thing? */}}
+      <option value="[[none]]" class="py-1" {{ if not $.DefaultKnot }}selected{{ end }}>
+        Choose a default knot
+      </option>
+      {{ range $.AvailableKnots }}
+        <option value="{{ . }}" class="py-1" {{ if eq . $.DefaultKnot }}selected{{ end }}>
+          {{ . }}
+        </option>
+      {{ end }}
+    </select>
+    <button class="btn flex gap-2 items-center" type="submit">
+      {{ i "check" "size-4" }}
+      {{ i "loader-circle" "w-4 h-4 animate-spin hidden group-[.htmx-request]:inline" }}
+    </button>
+  </form>
+</section>
 {{ end }}
 
 {{ define "register" }}

appview/pages/templates/repo/fork.html

···
                 value="{{ . }}"
                 class="mr-2"
                 id="domain-{{ . }}"
-                {{if eq (len $.Knots) 1}}checked{{end}}                
+                {{if eq (len $.Knots) 1}}checked
+                {{else if eq $.DefaultKnot .  }}checked
+                {{end}}
                 />
             <label for="domain-{{ . }}" class="dark:text-white">{{ . }}</label>
           </div>

appview/pages/templates/repo/new.html

···
             class="mr-2"
             id="domain-{{ . }}"
             required
-            {{if eq (len $.Knots) 1}}checked{{end}}
+            {{if eq (len $.Knots) 1}}checked
+            {{else if eq $.DefaultKnot .  }}checked
+            {{end}}
           />
           <label for="domain-{{ . }}" class="dark:text-white lowercase">{{ . }}</label>
         </div>

appview/repo/repo.go

···
 			return
 		}
 
+		defaultKnot := ""
+		knotPrefence, err := db.GetKnotPreference(rp.db, user.Did())
+		if err != nil {
+			rp.logger.Warn("gettings users knot preferences", "error", err)
+		}
+		if knotPrefence != nil {
+			defaultKnot = knotPrefence.DefaultKnot
+		}
+
 		rp.pages.ForkRepo(w, pages.ForkRepoParams{
 			LoggedInUser: user,
 			Knots:        knots,
 			RepoInfo:     rp.repoResolver.GetRepoInfo(r, user),
+			DefaultKnot:  defaultKnot,
 		})
 
 	case http.MethodPost:

appview/state/profile.go

···
 	s.updateProfile(profile, w, r)
 }
 
+func (s *State) UpdateDefaultKnotPreference(w http.ResponseWriter, r *http.Request) {
+	err := r.ParseForm()
+	if err != nil {
+		log.Println("invalid preference update form", err)
+		return
+	}
+	user := s.oauth.GetMultiAccountUser(r)
+
+	defaultKnot := r.Form.Get("default-knot")
+
+	if defaultKnot == "[[none]]" { // see pages/templates/knots/index.html for more info on why we use this value
+		defaultKnot = ""
+	}
+
+	err = db.UpsertKnotPreference(s.db, user.Did(), defaultKnot)
+	if err != nil {
+		log.Println("failed to update default knot preference", err)
+		return
+	}
+
+	s.pages.HxRefresh(w)
+}
+
 func (s *State) updateProfile(profile *models.Profile, w http.ResponseWriter, r *http.Request) {
 	user := s.oauth.GetMultiAccountUser(r)
 	tx, err := s.db.BeginTx(r.Context(), nil)

appview/state/router.go

···
 		r.Get("/edit-pins", s.EditPinsFragment)
 		r.Post("/bio", s.UpdateProfileBio)
 		r.Post("/pins", s.UpdateProfilePins)
+		r.Post("/default-knot", s.UpdateDefaultKnotPreference)
 	})
 
 	r.Mount("/settings", s.SettingsRouter())

appview/state/state.go

···
 			return
 		}
 
+		knots = append(knots, "hello")
+
+		defaultKnot := ""
+		knotPrefence, err := db.GetKnotPreference(s.db, user.Did())
+		if err != nil {
+			s.logger.Warn("gettings users knot preferences", "error", err)
+		}
+		if knotPrefence != nil {
+			defaultKnot = knotPrefence.DefaultKnot
+		}
+
 		s.pages.NewRepo(w, pages.NewRepoParams{
 			LoggedInUser: user,
 			Knots:        knots,
+			DefaultKnot:  defaultKnot,
 		})
 
 	case http.MethodPost: