appview: allows a default knot to be configured

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

appview/db/db.go

···
 		// 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,
···
 			create index if not exists idx_stars_created on stars(created);
 			create index if not exists idx_stars_subject_at_created on stars(subject_at, created);
 		`)
+		return err
+	})
+
+	orm.RunMigration(conn, logger, "add-default-knot-profile", func(tx *sql.Tx) error {
+		_, err := tx.Exec(`
+				alter table profile add column default_knot text;
+			`)
 		return err
 	})
 

appview/db/profile.go

···
 			description,
 			include_bluesky,
 			location,
-			pronouns
+			pronouns,
+			default_knot
 		)
 		values (?, ?, ?, ?, ?)`,
 		profile.Did,
···
 		includeBskyValue,
 		profile.Location,
 		profile.Pronouns,
+		profile.DefaultKnot,
 	)
 
 	if err != nil {
···
 func GetProfile(e Execer, did string) (*models.Profile, error) {
 	var profile models.Profile
 	var pronouns sql.Null[string]
+	var defaultKnot sql.Null[string]
 
 	profile.Did = did
 
 	includeBluesky := 0
 
 	err := e.QueryRow(
-		`select description, include_bluesky, location, pronouns from profile where did = ?`,
+		`select description, include_bluesky, location, pronouns, default_knot from profile where did = ?`,
 		did,
-	).Scan(&profile.Description, &includeBluesky, &profile.Location, &pronouns)
+	).Scan(&profile.Description, &includeBluesky, &profile.Location, &pronouns, &defaultKnot)
 	if err == sql.ErrNoRows {
 		profile := models.Profile{}
 		profile.Did = did
···
 
 	if pronouns.Valid {
 		profile.Pronouns = pronouns.V
+	}
+
+	if defaultKnot.Valid {
+		profile.DefaultKnot = defaultKnot.V
 	}
 
 	rows, err := e.Query(`select link from profile_links where did = ?`, did)

appview/knots/knots.go

···
 		return
 	}
 
+	defaultKnot := ""
+	profile, err := db.GetProfile(k.Db, user.Did())
+	if err != nil {
+		k.Logger.Warn("gettings user profile to get default knot", "error", err)
+	}
+	if profile != nil {
+		defaultKnot = profile.DefaultKnot
+	}
+
 	k.Pages.Knots(w, pages.KnotsParams{
 		LoggedInUser:  user,
 		Registrations: registrations,
 		Tabs:          knotsTabs,
 		Tab:           "knots",
+		DefaultKnot:   defaultKnot,
 	})
 }
 

appview/models/profile.go

···
 	Stats          [2]VanityStat
 	PinnedRepos    [6]syntax.ATURI
 	Pronouns       string
+	DefaultKnot    string
 }
 
 func (p Profile) IsLinksEmpty() bool {

appview/pages/pages.go

···
 	Registrations []models.Registration
 	Tabs          []map[string]any
 	Tab           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 }}
···
       {{ 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>
+    <select id="default-knot" name="default-knot"
+      class="p-1 max-w-64 border border-gray-200 bg-white dark:bg-gray-800 dark:text-white dark:border-gray-700"
+      hx-post="/profile/default-knot"
+      hx-swap="none"
+      name="default-knot">
+        <option value="" >
+          Choose a default Knot
+        </option>
+        <option value="knot1.tangled.sh" {{if eq $.DefaultKnot "knot1.tangled.sh"}}selected{{end}} >
+          knot1.tangled.sh
+        </option>
+      {{ range $registration := .Registrations  }}
+        <option value="{{ .Domain }}" class="py-1" {{if eq $.DefaultKnot .Domain}}selected{{end}}>
+          {{ .Domain }}
+        </option>
+      {{ end }}
+    </select>
   </section>
 {{ end }}
 

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 := ""
+		profile, err := db.GetProfile(rp.db, user.Did())
+		if err != nil {
+			rp.logger.Warn("gettings user profile to get default knot", "error", err)
+		}
+		if profile != nil {
+			defaultKnot = profile.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) UpdateProfileDefaultKnot(w http.ResponseWriter, r *http.Request) {
+	err := r.ParseForm()
+	if err != nil {
+		log.Println("invalid profile update form", err)
+		return
+	}
+	user := s.oauth.GetUser(r)
+
+	profile, err := db.GetProfile(s.db, user.Did)
+	if err != nil {
+		log.Printf("getting profile data for %s: %s", user.Did, err)
+	}
+
+	if profile == nil {
+		return
+	}
+
+	profile.DefaultKnot = r.Form.Get("default-knot")
+
+	tx, err := s.db.BeginTx(r.Context(), nil)
+	if err != nil {
+		log.Println("failed to start transaction", err)
+		return
+	}
+
+	err = db.UpsertProfile(tx, profile)
+	if err != nil {
+		log.Println("failed to update profile", err)
+		return
+	}
+}
+
 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.UpdateProfileDefaultKnot)
 	})
 
 	r.Mount("/settings", s.SettingsRouter())

appview/state/state.go

···
 			return
 		}
 
+		defaultKnot := ""
+		profile, err := db.GetProfile(s.db, user.Did())
+		if err != nil {
+			s.logger.Warn("gettings user profile to get default knot", "error", err)
+		}
+		if profile != nil {
+			defaultKnot = profile.DefaultKnot
+		}
+
 		s.pages.NewRepo(w, pages.NewRepoParams{
 			LoggedInUser: user,
 			Knots:        knots,
+			DefaultKnot:  defaultKnot,
 		})
 
 	case http.MethodPost: