patch of appview/repo: split up handlers into separate files · round #2 · pull #763 · tangled.org/core

+49

appview/repo/archive.go

···

       1
       1
       +
       package repo

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"fmt"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       	"net/url"

     

       7
       7
       +
       	"strings"

     

       8
       8
       +
       

     

       9
       9
       +
       	"tangled.org/core/api/tangled"

     

       10
       10
       +
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       11
       11
       +
       

     

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

     

       13
       13
       +
       	"github.com/go-chi/chi/v5"

     

       14
       14
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

       15
       15
       +
       )

     

       16
       16
       +
       

     

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

     

       18
       18
       +
       	l := rp.logger.With("handler", "DownloadArchive")

     

       19
       19
       +
       	ref := chi.URLParam(r, "ref")

     

       20
       20
       +
       	ref, _ = url.PathUnescape(ref)

     

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

     

       22
       22
       +
       	if err != nil {

     

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

     

       24
       24
       +
       		return

     

       25
       25
       +
       	}

     

       26
       26
       +
       	scheme := "http"

     

       27
       27
       +
       	if !rp.config.Core.Dev {

     

       28
       28
       +
       		scheme = "https"

     

       29
       29
       +
       	}

     

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

     

       31
       31
       +
       	xrpcc := &indigoxrpc.Client{

     

       32
       32
       +
       		Host: host,

     

       33
       33
       +
       	}

     

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

     

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

     

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

     

       37
       37
       +
       		l.Error("failed to call XRPC repo.archive", "err", xrpcerr)

     

       38
       38
       +
       		rp.pages.Error503(w)

     

       39
       39
       +
       		return

     

       40
       40
       +
       	}

     

       41
       41
       +
       	// Set headers for file download, just pass along whatever the knot specifies

     

       42
       42
       +
       	safeRefFilename := strings.ReplaceAll(plumbing.ReferenceName(ref).Short(), "/", "-")

     

       43
       43
       +
       	filename := fmt.Sprintf("%s-%s.tar.gz", f.Name, safeRefFilename)

     

       44
       44
       +
       	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))

     

       45
       45
       +
       	w.Header().Set("Content-Type", "application/gzip")

     

       46
       46
       +
       	w.Header().Set("Content-Length", fmt.Sprintf("%d", len(archiveBytes)))

     

       47
       47
       +
       	// Write the archive data directly

     

       48
       48
       +
       	w.Write(archiveBytes)

     

       49
       49
       +
       }

+219

appview/repo/blob.go

···

       1
       1
       +
       package repo

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"fmt"

     

       5
       5
       +
       	"io"

     

       6
       6
       +
       	"net/http"

     

       7
       7
       +
       	"net/url"

     

       8
       8
       +
       	"path/filepath"

     

       9
       9
       +
       	"slices"

     

       10
       10
       +
       	"strings"

     

       11
       11
       +
       

     

       12
       12
       +
       	"tangled.org/core/api/tangled"

     

       13
       13
       +
       	"tangled.org/core/appview/pages"

     

       14
       14
       +
       	"tangled.org/core/appview/pages/markup"

     

       15
       15
       +
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       16
       16
       +
       

     

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

     

       18
       18
       +
       	"github.com/go-chi/chi/v5"

     

       19
       19
       +
       )

     

       20
       20
       +
       

     

       21
       21
       +
       func (rp *Repo) Blob(w http.ResponseWriter, r *http.Request) {

     

       22
       22
       +
       	l := rp.logger.With("handler", "RepoBlob")

     

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

     

       24
       24
       +
       	if err != nil {

     

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

     

       26
       26
       +
       		return

     

       27
       27
       +
       	}

     

       28
       28
       +
       	ref := chi.URLParam(r, "ref")

     

       29
       29
       +
       	ref, _ = url.PathUnescape(ref)

     

       30
       30
       +
       	filePath := chi.URLParam(r, "*")

     

       31
       31
       +
       	filePath, _ = url.PathUnescape(filePath)

     

       32
       32
       +
       	scheme := "http"

     

       33
       33
       +
       	if !rp.config.Core.Dev {

     

       34
       34
       +
       		scheme = "https"

     

       35
       35
       +
       	}

     

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

     

       37
       37
       +
       	xrpcc := &indigoxrpc.Client{

     

       38
       38
       +
       		Host: host,

     

       39
       39
       +
       	}

     

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

     

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

     

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

     

       43
       43
       +
       		l.Error("failed to call XRPC repo.blob", "err", xrpcerr)

     

       44
       44
       +
       		rp.pages.Error503(w)

     

       45
       45
       +
       		return

     

       46
       46
       +
       	}

     

       47
       47
       +
       	// Use XRPC response directly instead of converting to internal types

     

       48
       48
       +
       	var breadcrumbs [][]string

     

       49
       49
       +
       	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})

     

       50
       50
       +
       	if filePath != "" {

     

       51
       51
       +
       		for idx, elem := range strings.Split(filePath, "/") {

     

       52
       52
       +
       			breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], url.PathEscape(elem))})

     

       53
       53
       +
       		}

     

       54
       54
       +
       	}

     

       55
       55
       +
       	showRendered := false

     

       56
       56
       +
       	renderToggle := false

     

       57
       57
       +
       	if markup.GetFormat(resp.Path) == markup.FormatMarkdown {

     

       58
       58
       +
       		renderToggle = true

     

       59
       59
       +
       		showRendered = r.URL.Query().Get("code") != "true"

     

       60
       60
       +
       	}

     

       61
       61
       +
       	var unsupported bool

     

       62
       62
       +
       	var isImage bool

     

       63
       63
       +
       	var isVideo bool

     

       64
       64
       +
       	var contentSrc string

     

       65
       65
       +
       	if resp.IsBinary != nil && *resp.IsBinary {

     

       66
       66
       +
       		ext := strings.ToLower(filepath.Ext(resp.Path))

     

       67
       67
       +
       		switch ext {

     

       68
       68
       +
       		case ".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp":

     

       69
       69
       +
       			isImage = true

     

       70
       70
       +
       		case ".mp4", ".webm", ".ogg", ".mov", ".avi":

     

       71
       71
       +
       			isVideo = true

     

       72
       72
       +
       		default:

     

       73
       73
       +
       			unsupported = true

     

       74
       74
       +
       		}

     

       75
       75
       +
       		// fetch the raw binary content using sh.tangled.repo.blob xrpc

     

       76
       76
       +
       		repoName := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       77
       77
       +
       		baseURL := &url.URL{

     

       78
       78
       +
       			Scheme: scheme,

     

       79
       79
       +
       			Host:   f.Knot,

     

       80
       80
       +
       			Path:   "/xrpc/sh.tangled.repo.blob",

     

       81
       81
       +
       		}

     

       82
       82
       +
       		query := baseURL.Query()

     

       83
       83
       +
       		query.Set("repo", repoName)

     

       84
       84
       +
       		query.Set("ref", ref)

     

       85
       85
       +
       		query.Set("path", filePath)

     

       86
       86
       +
       		query.Set("raw", "true")

     

       87
       87
       +
       		baseURL.RawQuery = query.Encode()

     

       88
       88
       +
       		blobURL := baseURL.String()

     

       89
       89
       +
       		contentSrc = blobURL

     

       90
       90
       +
       		if !rp.config.Core.Dev {

     

       91
       91
       +
       			contentSrc = markup.GenerateCamoURL(rp.config.Camo.Host, rp.config.Camo.SharedSecret, blobURL)

     

       92
       92
       +
       		}

     

       93
       93
       +
       	}

     

       94
       94
       +
       	lines := 0

     

       95
       95
       +
       	if resp.IsBinary == nil || !*resp.IsBinary {

     

       96
       96
       +
       		lines = strings.Count(resp.Content, "\n") + 1

     

       97
       97
       +
       	}

     

       98
       98
       +
       	var sizeHint uint64

     

       99
       99
       +
       	if resp.Size != nil {

     

       100
       100
       +
       		sizeHint = uint64(*resp.Size)

     

       101
       101
       +
       	} else {

     

       102
       102
       +
       		sizeHint = uint64(len(resp.Content))

     

       103
       103
       +
       	}

     

       104
       104
       +
       	user := rp.oauth.GetUser(r)

     

       105
       105
       +
       	// Determine if content is binary (dereference pointer)

     

       106
       106
       +
       	isBinary := false

     

       107
       107
       +
       	if resp.IsBinary != nil {

     

       108
       108
       +
       		isBinary = *resp.IsBinary

     

       109
       109
       +
       	}

     

       110
       110
       +
       	rp.pages.RepoBlob(w, pages.RepoBlobParams{

     

       111
       111
       +
       		LoggedInUser:    user,

     

       112
       112
       +
       		RepoInfo:        f.RepoInfo(user),

     

       113
       113
       +
       		BreadCrumbs:     breadcrumbs,

     

       114
       114
       +
       		ShowRendered:    showRendered,

     

       115
       115
       +
       		RenderToggle:    renderToggle,

     

       116
       116
       +
       		Unsupported:     unsupported,

     

       117
       117
       +
       		IsImage:         isImage,

     

       118
       118
       +
       		IsVideo:         isVideo,

     

       119
       119
       +
       		ContentSrc:      contentSrc,

     

       120
       120
       +
       		RepoBlob_Output: resp,

     

       121
       121
       +
       		Contents:        resp.Content,

     

       122
       122
       +
       		Lines:           lines,

     

       123
       123
       +
       		SizeHint:        sizeHint,

     

       124
       124
       +
       		IsBinary:        isBinary,

     

       125
       125
       +
       	})

     

       126
       126
       +
       }

     

       127
       127
       +
       

     

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

     

       129
       129
       +
       	l := rp.logger.With("handler", "RepoBlobRaw")

     

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

     

       131
       131
       +
       	if err != nil {

     

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

     

       133
       133
       +
       		w.WriteHeader(http.StatusBadRequest)

     

       134
       134
       +
       		return

     

       135
       135
       +
       	}

     

       136
       136
       +
       	ref := chi.URLParam(r, "ref")

     

       137
       137
       +
       	ref, _ = url.PathUnescape(ref)

     

       138
       138
       +
       	filePath := chi.URLParam(r, "*")

     

       139
       139
       +
       	filePath, _ = url.PathUnescape(filePath)

     

       140
       140
       +
       	scheme := "http"

     

       141
       141
       +
       	if !rp.config.Core.Dev {

     

       142
       142
       +
       		scheme = "https"

     

       143
       143
       +
       	}

     

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

     

       145
       145
       +
       	baseURL := &url.URL{

     

       146
       146
       +
       		Scheme: scheme,

     

       147
       147
       +
       		Host:   f.Knot,

     

       148
       148
       +
       		Path:   "/xrpc/sh.tangled.repo.blob",

     

       149
       149
       +
       	}

     

       150
       150
       +
       	query := baseURL.Query()

     

       151
       151
       +
       	query.Set("repo", repo)

     

       152
       152
       +
       	query.Set("ref", ref)

     

       153
       153
       +
       	query.Set("path", filePath)

     

       154
       154
       +
       	query.Set("raw", "true")

     

       155
       155
       +
       	baseURL.RawQuery = query.Encode()

     

       156
       156
       +
       	blobURL := baseURL.String()

     

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

     

       158
       158
       +
       	if err != nil {

     

       159
       159
       +
       		l.Error("failed to create request", "err", err)

     

       160
       160
       +
       		return

     

       161
       161
       +
       	}

     

       162
       162
       +
       	// forward the If-None-Match header

     

       163
       163
       +
       	if clientETag := r.Header.Get("If-None-Match"); clientETag != "" {

     

       164
       164
       +
       		req.Header.Set("If-None-Match", clientETag)

     

       165
       165
       +
       	}

     

       166
       166
       +
       	client := &http.Client{}

     

       167
       167
       +
       	resp, err := client.Do(req)

     

       168
       168
       +
       	if err != nil {

     

       169
       169
       +
       		l.Error("failed to reach knotserver", "err", err)

     

       170
       170
       +
       		rp.pages.Error503(w)

     

       171
       171
       +
       		return

     

       172
       172
       +
       	}

     

       173
       173
       +
       	defer resp.Body.Close()

     

       174
       174
       +
       	// forward 304 not modified

     

       175
       175
       +
       	if resp.StatusCode == http.StatusNotModified {

     

       176
       176
       +
       		w.WriteHeader(http.StatusNotModified)

     

       177
       177
       +
       		return

     

       178
       178
       +
       	}

     

       179
       179
       +
       	if resp.StatusCode != http.StatusOK {

     

       180
       180
       +
       		l.Error("knotserver returned non-OK status for raw blob", "url", blobURL, "statuscode", resp.StatusCode)

     

       181
       181
       +
       		w.WriteHeader(resp.StatusCode)

     

       182
       182
       +
       		_, _ = io.Copy(w, resp.Body)

     

       183
       183
       +
       		return

     

       184
       184
       +
       	}

     

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

     

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

     

       187
       187
       +
       	if err != nil {

     

       188
       188
       +
       		l.Error("error reading response body from knotserver", "err", err)

     

       189
       189
       +
       		w.WriteHeader(http.StatusInternalServerError)

     

       190
       190
       +
       		return

     

       191
       191
       +
       	}

     

       192
       192
       +
       	if strings.HasPrefix(contentType, "text/") || isTextualMimeType(contentType) {

     

       193
       193
       +
       		// serve all textual content as text/plain

     

       194
       194
       +
       		w.Header().Set("Content-Type", "text/plain; charset=utf-8")

     

       195
       195
       +
       		w.Write(body)

     

       196
       196
       +
       	} else if strings.HasPrefix(contentType, "image/") || strings.HasPrefix(contentType, "video/") {

     

       197
       197
       +
       		// serve images and videos with their original content type

     

       198
       198
       +
       		w.Header().Set("Content-Type", contentType)

     

       199
       199
       +
       		w.Write(body)

     

       200
       200
       +
       	} else {

     

       201
       201
       +
       		w.WriteHeader(http.StatusUnsupportedMediaType)

     

       202
       202
       +
       		w.Write([]byte("unsupported content type"))

     

       203
       203
       +
       		return

     

       204
       204
       +
       	}

     

       205
       205
       +
       }

     

       206
       206
       +
       

     

       207
       207
       +
       func isTextualMimeType(mimeType string) bool {

     

       208
       208
       +
       	textualTypes := []string{

     

       209
       209
       +
       		"application/json",

     

       210
       210
       +
       		"application/xml",

     

       211
       211
       +
       		"application/yaml",

     

       212
       212
       +
       		"application/x-yaml",

     

       213
       213
       +
       		"application/toml",

     

       214
       214
       +
       		"application/javascript",

     

       215
       215
       +
       		"application/ecmascript",

     

       216
       216
       +
       		"message/",

     

       217
       217
       +
       	}

     

       218
       218
       +
       	return slices.Contains(textualTypes, mimeType)

     

       219
       219
       +
       }

+95

appview/repo/branches.go

···

       1
       1
       +
       package repo

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"net/http"

     

       7
       7
       +
       

     

       8
       8
       +
       	"tangled.org/core/api/tangled"

     

       9
       9
       +
       	"tangled.org/core/appview/oauth"

     

       10
       10
       +
       	"tangled.org/core/appview/pages"

     

       11
       11
       +
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       12
       12
       +
       	"tangled.org/core/types"

     

       13
       13
       +
       

     

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

     

       15
       15
       +
       )

     

       16
       16
       +
       

     

       17
       17
       +
       func (rp *Repo) Branches(w http.ResponseWriter, r *http.Request) {

     

       18
       18
       +
       	l := rp.logger.With("handler", "RepoBranches")

     

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

     

       20
       20
       +
       	if err != nil {

     

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

     

       22
       22
       +
       		return

     

       23
       23
       +
       	}

     

       24
       24
       +
       	scheme := "http"

     

       25
       25
       +
       	if !rp.config.Core.Dev {

     

       26
       26
       +
       		scheme = "https"

     

       27
       27
       +
       	}

     

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

     

       29
       29
       +
       	xrpcc := &indigoxrpc.Client{

     

       30
       30
       +
       		Host: host,

     

       31
       31
       +
       	}

     

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

     

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

     

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

     

       35
       35
       +
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       36
       36
       +
       		rp.pages.Error503(w)

     

       37
       37
       +
       		return

     

       38
       38
       +
       	}

     

       39
       39
       +
       	var result types.RepoBranchesResponse

     

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

     

       41
       41
       +
       		l.Error("failed to decode XRPC response", "err", err)

     

       42
       42
       +
       		rp.pages.Error503(w)

     

       43
       43
       +
       		return

     

       44
       44
       +
       	}

     

       45
       45
       +
       	sortBranches(result.Branches)

     

       46
       46
       +
       	user := rp.oauth.GetUser(r)

     

       47
       47
       +
       	rp.pages.RepoBranches(w, pages.RepoBranchesParams{

     

       48
       48
       +
       		LoggedInUser:         user,

     

       49
       49
       +
       		RepoInfo:             f.RepoInfo(user),

     

       50
       50
       +
       		RepoBranchesResponse: result,

     

       51
       51
       +
       	})

     

       52
       52
       +
       }

     

       53
       53
       +
       

     

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

     

       55
       55
       +
       	l := rp.logger.With("handler", "DeleteBranch")

     

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

     

       57
       57
       +
       	if err != nil {

     

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

     

       59
       59
       +
       		return

     

       60
       60
       +
       	}

     

       61
       61
       +
       	noticeId := "delete-branch-error"

     

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

     

       63
       63
       +
       		l.Error(msg, "err", err)

     

       64
       64
       +
       		rp.pages.Notice(w, noticeId, msg)

     

       65
       65
       +
       	}

     

       66
       66
       +
       	branch := r.FormValue("branch")

     

       67
       67
       +
       	if branch == "" {

     

       68
       68
       +
       		fail("No branch provided.", nil)

     

       69
       69
       +
       		return

     

       70
       70
       +
       	}

     

       71
       71
       +
       	client, err := rp.oauth.ServiceClient(

     

       72
       72
       +
       		r,

     

       73
       73
       +
       		oauth.WithService(f.Knot),

     

       74
       74
       +
       		oauth.WithLxm(tangled.RepoDeleteBranchNSID),

     

       75
       75
       +
       		oauth.WithDev(rp.config.Core.Dev),

     

       76
       76
       +
       	)

     

       77
       77
       +
       	if err != nil {

     

       78
       78
       +
       		fail("Failed to connect to knotserver", nil)

     

       79
       79
       +
       		return

     

       80
       80
       +
       	}

     

       81
       81
       +
       	err = tangled.RepoDeleteBranch(

     

       82
       82
       +
       		r.Context(),

     

       83
       83
       +
       		client,

     

       84
       84
       +
       		&tangled.RepoDeleteBranch_Input{

     

       85
       85
       +
       			Branch: branch,

     

       86
       86
       +
       			Repo:   f.RepoAt().String(),

     

       87
       87
       +
       		},

     

       88
       88
       +
       	)

     

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

     

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

     

       91
       91
       +
       		return

     

       92
       92
       +
       	}

     

       93
       93
       +
       	l.Error("deleted branch from knot", "branch", branch, "repo", f.RepoAt())

     

       94
       94
       +
       	rp.pages.HxRefresh(w)

     

       95
       95
       +
       }

+214

appview/repo/compare.go

···

       1
       1
       +
       package repo

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"net/http"

     

       7
       7
       +
       	"net/url"

     

       8
       8
       +
       	"strings"

     

       9
       9
       +
       

     

       10
       10
       +
       	"tangled.org/core/api/tangled"

     

       11
       11
       +
       	"tangled.org/core/appview/pages"

     

       12
       12
       +
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       13
       13
       +
       	"tangled.org/core/patchutil"

     

       14
       14
       +
       	"tangled.org/core/types"

     

       15
       15
       +
       

     

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

     

       17
       17
       +
       	"github.com/go-chi/chi/v5"

     

       18
       18
       +
       )

     

       19
       19
       +
       

     

       20
       20
       +
       func (rp *Repo) CompareNew(w http.ResponseWriter, r *http.Request) {

     

       21
       21
       +
       	l := rp.logger.With("handler", "RepoCompareNew")

     

       22
       22
       +
       

     

       23
       23
       +
       	user := rp.oauth.GetUser(r)

     

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

     

       25
       25
       +
       	if err != nil {

     

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

     

       27
       27
       +
       		return

     

       28
       28
       +
       	}

     

       29
       29
       +
       

     

       30
       30
       +
       	scheme := "http"

     

       31
       31
       +
       	if !rp.config.Core.Dev {

     

       32
       32
       +
       		scheme = "https"

     

       33
       33
       +
       	}

     

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

     

       35
       35
       +
       	xrpcc := &indigoxrpc.Client{

     

       36
       36
       +
       		Host: host,

     

       37
       37
       +
       	}

     

       38
       38
       +
       

     

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

     

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

     

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

     

       42
       42
       +
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       43
       43
       +
       		rp.pages.Error503(w)

     

       44
       44
       +
       		return

     

       45
       45
       +
       	}

     

       46
       46
       +
       

     

       47
       47
       +
       	var branchResult types.RepoBranchesResponse

     

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

     

       49
       49
       +
       		l.Error("failed to decode XRPC branches response", "err", err)

     

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

     

       51
       51
       +
       		return

     

       52
       52
       +
       	}

     

       53
       53
       +
       	branches := branchResult.Branches

     

       54
       54
       +
       

     

       55
       55
       +
       	sortBranches(branches)

     

       56
       56
       +
       

     

       57
       57
       +
       	var defaultBranch string

     

       58
       58
       +
       	for _, b := range branches {

     

       59
       59
       +
       		if b.IsDefault {

     

       60
       60
       +
       			defaultBranch = b.Name

     

       61
       61
       +
       		}

     

       62
       62
       +
       	}

     

       63
       63
       +
       

     

       64
       64
       +
       	base := defaultBranch

     

       65
       65
       +
       	head := defaultBranch

     

       66
       66
       +
       

     

       67
       67
       +
       	params := r.URL.Query()

     

       68
       68
       +
       	queryBase := params.Get("base")

     

       69
       69
       +
       	queryHead := params.Get("head")

     

       70
       70
       +
       	if queryBase != "" {

     

       71
       71
       +
       		base = queryBase

     

       72
       72
       +
       	}

     

       73
       73
       +
       	if queryHead != "" {

     

       74
       74
       +
       		head = queryHead

     

       75
       75
       +
       	}

     

       76
       76
       +
       

     

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

     

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

     

       79
       79
       +
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       80
       80
       +
       		rp.pages.Error503(w)

     

       81
       81
       +
       		return

     

       82
       82
       +
       	}

     

       83
       83
       +
       

     

       84
       84
       +
       	var tags types.RepoTagsResponse

     

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

     

       86
       86
       +
       		l.Error("failed to decode XRPC tags response", "err", err)

     

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

     

       88
       88
       +
       		return

     

       89
       89
       +
       	}

     

       90
       90
       +
       

     

       91
       91
       +
       	repoinfo := f.RepoInfo(user)

     

       92
       92
       +
       

     

       93
       93
       +
       	rp.pages.RepoCompareNew(w, pages.RepoCompareNewParams{

     

       94
       94
       +
       		LoggedInUser: user,

     

       95
       95
       +
       		RepoInfo:     repoinfo,

     

       96
       96
       +
       		Branches:     branches,

     

       97
       97
       +
       		Tags:         tags.Tags,

     

       98
       98
       +
       		Base:         base,

     

       99
       99
       +
       		Head:         head,

     

       100
       100
       +
       	})

     

       101
       101
       +
       }

     

       102
       102
       +
       

     

       103
       103
       +
       func (rp *Repo) Compare(w http.ResponseWriter, r *http.Request) {

     

       104
       104
       +
       	l := rp.logger.With("handler", "RepoCompare")

     

       105
       105
       +
       

     

       106
       106
       +
       	user := rp.oauth.GetUser(r)

     

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

     

       108
       108
       +
       	if err != nil {

     

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

     

       110
       110
       +
       		return

     

       111
       111
       +
       	}

     

       112
       112
       +
       

     

       113
       113
       +
       	var diffOpts types.DiffOpts

     

       114
       114
       +
       	if d := r.URL.Query().Get("diff"); d == "split" {

     

       115
       115
       +
       		diffOpts.Split = true

     

       116
       116
       +
       	}

     

       117
       117
       +
       

     

       118
       118
       +
       	// if user is navigating to one of

     

       119
       119
       +
       	//   /compare/{base}/{head}

     

       120
       120
       +
       	//   /compare/{base}...{head}

     

       121
       121
       +
       	base := chi.URLParam(r, "base")

     

       122
       122
       +
       	head := chi.URLParam(r, "head")

     

       123
       123
       +
       	if base == "" && head == "" {

     

       124
       124
       +
       		rest := chi.URLParam(r, "*") // master...feature/xyz

     

       125
       125
       +
       		parts := strings.SplitN(rest, "...", 2)

     

       126
       126
       +
       		if len(parts) == 2 {

     

       127
       127
       +
       			base = parts[0]

     

       128
       128
       +
       			head = parts[1]

     

       129
       129
       +
       		}

     

       130
       130
       +
       	}

     

       131
       131
       +
       

     

       132
       132
       +
       	base, _ = url.PathUnescape(base)

     

       133
       133
       +
       	head, _ = url.PathUnescape(head)

     

       134
       134
       +
       

     

       135
       135
       +
       	if base == "" || head == "" {

     

       136
       136
       +
       		l.Error("invalid comparison")

     

       137
       137
       +
       		rp.pages.Error404(w)

     

       138
       138
       +
       		return

     

       139
       139
       +
       	}

     

       140
       140
       +
       

     

       141
       141
       +
       	scheme := "http"

     

       142
       142
       +
       	if !rp.config.Core.Dev {

     

       143
       143
       +
       		scheme = "https"

     

       144
       144
       +
       	}

     

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

     

       146
       146
       +
       	xrpcc := &indigoxrpc.Client{

     

       147
       147
       +
       		Host: host,

     

       148
       148
       +
       	}

     

       149
       149
       +
       

     

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

     

       151
       151
       +
       

     

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

     

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

     

       154
       154
       +
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       155
       155
       +
       		rp.pages.Error503(w)

     

       156
       156
       +
       		return

     

       157
       157
       +
       	}

     

       158
       158
       +
       

     

       159
       159
       +
       	var branches types.RepoBranchesResponse

     

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

     

       161
       161
       +
       		l.Error("failed to decode XRPC branches response", "err", err)

     

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

     

       163
       163
       +
       		return

     

       164
       164
       +
       	}

     

       165
       165
       +
       

     

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

     

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

     

       168
       168
       +
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       169
       169
       +
       		rp.pages.Error503(w)

     

       170
       170
       +
       		return

     

       171
       171
       +
       	}

     

       172
       172
       +
       

     

       173
       173
       +
       	var tags types.RepoTagsResponse

     

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

     

       175
       175
       +
       		l.Error("failed to decode XRPC tags response", "err", err)

     

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

     

       177
       177
       +
       		return

     

       178
       178
       +
       	}

     

       179
       179
       +
       

     

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

     

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

     

       182
       182
       +
       		l.Error("failed to call XRPC repo.compare", "err", xrpcerr)

     

       183
       183
       +
       		rp.pages.Error503(w)

     

       184
       184
       +
       		return

     

       185
       185
       +
       	}

     

       186
       186
       +
       

     

       187
       187
       +
       	var formatPatch types.RepoFormatPatchResponse

     

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

     

       189
       189
       +
       		l.Error("failed to decode XRPC compare response", "err", err)

     

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

     

       191
       191
       +
       		return

     

       192
       192
       +
       	}

     

       193
       193
       +
       

     

       194
       194
       +
       	var diff types.NiceDiff

     

       195
       195
       +
       	if formatPatch.CombinedPatchRaw != "" {

     

       196
       196
       +
       		diff = patchutil.AsNiceDiff(formatPatch.CombinedPatchRaw, base)

     

       197
       197
       +
       	} else {

     

       198
       198
       +
       		diff = patchutil.AsNiceDiff(formatPatch.FormatPatchRaw, base)

     

       199
       199
       +
       	}

     

       200
       200
       +
       

     

       201
       201
       +
       	repoinfo := f.RepoInfo(user)

     

       202
       202
       +
       

     

       203
       203
       +
       	rp.pages.RepoCompare(w, pages.RepoCompareParams{

     

       204
       204
       +
       		LoggedInUser: user,

     

       205
       205
       +
       		RepoInfo:     repoinfo,

     

       206
       206
       +
       		Branches:     branches.Branches,

     

       207
       207
       +
       		Tags:         tags.Tags,

     

       208
       208
       +
       		Base:         base,

     

       209
       209
       +
       		Head:         head,

     

       210
       210
       +
       		Diff:         &diff,

     

       211
       211
       +
       		DiffOpts:     diffOpts,

     

       212
       212
       +
       	})

     

       213
       213
       +
       

     

       214
       214
       +
       }

+1 -1

appview/repo/feed.go

···

       146
       146
        
       	return fmt.Sprintf("%s in %s", base, repoName)

     

       147
       147
        
       }

     

       148
       148
        
       

     

       149
       149
       -
       func (rp *Repo) RepoAtomFeed(w http.ResponseWriter, r *http.Request) {

     

       149
       149
       +
       func (rp *Repo) AtomFeed(w http.ResponseWriter, r *http.Request) {

     

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

     

       151
       151
        
       	if err != nil {

     

       152
       152
        
       		log.Println("failed to fully resolve repo:", err)

+1 -1

appview/repo/index.go

···

       30
       30
        
       	"github.com/go-enry/go-enry/v2"

     

       31
       31
        
       )

     

       32
       32
        
       

     

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

     

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

     

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

     

       35
       35
        
       

     

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

+223

appview/repo/log.go

···

       1
       1
       +
       package repo

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"net/http"

     

       7
       7
       +
       	"net/url"

     

       8
       8
       +
       	"strconv"

     

       9
       9
       +
       

     

       10
       10
       +
       	"tangled.org/core/api/tangled"

     

       11
       11
       +
       	"tangled.org/core/appview/commitverify"

     

       12
       12
       +
       	"tangled.org/core/appview/db"

     

       13
       13
       +
       	"tangled.org/core/appview/models"

     

       14
       14
       +
       	"tangled.org/core/appview/pages"

     

       15
       15
       +
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       16
       16
       +
       	"tangled.org/core/types"

     

       17
       17
       +
       

     

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

     

       19
       19
       +
       	"github.com/go-chi/chi/v5"

     

       20
       20
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

       21
       21
       +
       )

     

       22
       22
       +
       

     

       23
       23
       +
       func (rp *Repo) Log(w http.ResponseWriter, r *http.Request) {

     

       24
       24
       +
       	l := rp.logger.With("handler", "RepoLog")

     

       25
       25
       +
       

     

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

     

       27
       27
       +
       	if err != nil {

     

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

     

       29
       29
       +
       		return

     

       30
       30
       +
       	}

     

       31
       31
       +
       

     

       32
       32
       +
       	page := 1

     

       33
       33
       +
       	if r.URL.Query().Get("page") != "" {

     

       34
       34
       +
       		page, err = strconv.Atoi(r.URL.Query().Get("page"))

     

       35
       35
       +
       		if err != nil {

     

       36
       36
       +
       			page = 1

     

       37
       37
       +
       		}

     

       38
       38
       +
       	}

     

       39
       39
       +
       

     

       40
       40
       +
       	ref := chi.URLParam(r, "ref")

     

       41
       41
       +
       	ref, _ = url.PathUnescape(ref)

     

       42
       42
       +
       

     

       43
       43
       +
       	scheme := "http"

     

       44
       44
       +
       	if !rp.config.Core.Dev {

     

       45
       45
       +
       		scheme = "https"

     

       46
       46
       +
       	}

     

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

     

       48
       48
       +
       	xrpcc := &indigoxrpc.Client{

     

       49
       49
       +
       		Host: host,

     

       50
       50
       +
       	}

     

       51
       51
       +
       

     

       52
       52
       +
       	limit := int64(60)

     

       53
       53
       +
       	cursor := ""

     

       54
       54
       +
       	if page > 1 {

     

       55
       55
       +
       		// Convert page number to cursor (offset)

     

       56
       56
       +
       		offset := (page - 1) * int(limit)

     

       57
       57
       +
       		cursor = strconv.Itoa(offset)

     

       58
       58
       +
       	}

     

       59
       59
       +
       

     

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

     

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

     

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

     

       63
       63
       +
       		l.Error("failed to call XRPC repo.log", "err", xrpcerr)

     

       64
       64
       +
       		rp.pages.Error503(w)

     

       65
       65
       +
       		return

     

       66
       66
       +
       	}

     

       67
       67
       +
       

     

       68
       68
       +
       	var xrpcResp types.RepoLogResponse

     

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

     

       70
       70
       +
       		l.Error("failed to decode XRPC response", "err", err)

     

       71
       71
       +
       		rp.pages.Error503(w)

     

       72
       72
       +
       		return

     

       73
       73
       +
       	}

     

       74
       74
       +
       

     

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

     

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

     

       77
       77
       +
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       78
       78
       +
       		rp.pages.Error503(w)

     

       79
       79
       +
       		return

     

       80
       80
       +
       	}

     

       81
       81
       +
       

     

       82
       82
       +
       	tagMap := make(map[string][]string)

     

       83
       83
       +
       	if tagBytes != nil {

     

       84
       84
       +
       		var tagResp types.RepoTagsResponse

     

       85
       85
       +
       		if err := json.Unmarshal(tagBytes, &tagResp); err == nil {

     

       86
       86
       +
       			for _, tag := range tagResp.Tags {

     

       87
       87
       +
       				hash := tag.Hash

     

       88
       88
       +
       				if tag.Tag != nil {

     

       89
       89
       +
       					hash = tag.Tag.Target.String()

     

       90
       90
       +
       				}

     

       91
       91
       +
       				tagMap[hash] = append(tagMap[hash], tag.Name)

     

       92
       92
       +
       			}

     

       93
       93
       +
       		}

     

       94
       94
       +
       	}

     

       95
       95
       +
       

     

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

     

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

     

       98
       98
       +
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       99
       99
       +
       		rp.pages.Error503(w)

     

       100
       100
       +
       		return

     

       101
       101
       +
       	}

     

       102
       102
       +
       

     

       103
       103
       +
       	if branchBytes != nil {

     

       104
       104
       +
       		var branchResp types.RepoBranchesResponse

     

       105
       105
       +
       		if err := json.Unmarshal(branchBytes, &branchResp); err == nil {

     

       106
       106
       +
       			for _, branch := range branchResp.Branches {

     

       107
       107
       +
       				tagMap[branch.Hash] = append(tagMap[branch.Hash], branch.Name)

     

       108
       108
       +
       			}

     

       109
       109
       +
       		}

     

       110
       110
       +
       	}

     

       111
       111
       +
       

     

       112
       112
       +
       	user := rp.oauth.GetUser(r)

     

       113
       113
       +
       

     

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

     

       115
       115
       +
       	if err != nil {

     

       116
       116
       +
       		l.Error("failed to fetch email to did mapping", "err", err)

     

       117
       117
       +
       	}

     

       118
       118
       +
       

     

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

     

       120
       120
       +
       	if err != nil {

     

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

     

       122
       122
       +
       	}

     

       123
       123
       +
       

     

       124
       124
       +
       	repoInfo := f.RepoInfo(user)

     

       125
       125
       +
       

     

       126
       126
       +
       	var shas []string

     

       127
       127
       +
       	for _, c := range xrpcResp.Commits {

     

       128
       128
       +
       		shas = append(shas, c.Hash.String())

     

       129
       129
       +
       	}

     

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

     

       131
       131
       +
       	if err != nil {

     

       132
       132
       +
       		l.Error("failed to getPipelineStatuses", "err", err)

     

       133
       133
       +
       		// non-fatal

     

       134
       134
       +
       	}

     

       135
       135
       +
       

     

       136
       136
       +
       	rp.pages.RepoLog(w, pages.RepoLogParams{

     

       137
       137
       +
       		LoggedInUser:    user,

     

       138
       138
       +
       		TagMap:          tagMap,

     

       139
       139
       +
       		RepoInfo:        repoInfo,

     

       140
       140
       +
       		RepoLogResponse: xrpcResp,

     

       141
       141
       +
       		EmailToDid:      emailToDidMap,

     

       142
       142
       +
       		VerifiedCommits: vc,

     

       143
       143
       +
       		Pipelines:       pipelines,

     

       144
       144
       +
       	})

     

       145
       145
       +
       }

     

       146
       146
       +
       

     

       147
       147
       +
       func (rp *Repo) Commit(w http.ResponseWriter, r *http.Request) {

     

       148
       148
       +
       	l := rp.logger.With("handler", "RepoCommit")

     

       149
       149
       +
       

     

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

     

       151
       151
       +
       	if err != nil {

     

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

     

       153
       153
       +
       		return

     

       154
       154
       +
       	}

     

       155
       155
       +
       	ref := chi.URLParam(r, "ref")

     

       156
       156
       +
       	ref, _ = url.PathUnescape(ref)

     

       157
       157
       +
       

     

       158
       158
       +
       	var diffOpts types.DiffOpts

     

       159
       159
       +
       	if d := r.URL.Query().Get("diff"); d == "split" {

     

       160
       160
       +
       		diffOpts.Split = true

     

       161
       161
       +
       	}

     

       162
       162
       +
       

     

       163
       163
       +
       	if !plumbing.IsHash(ref) {

     

       164
       164
       +
       		rp.pages.Error404(w)

     

       165
       165
       +
       		return

     

       166
       166
       +
       	}

     

       167
       167
       +
       

     

       168
       168
       +
       	scheme := "http"

     

       169
       169
       +
       	if !rp.config.Core.Dev {

     

       170
       170
       +
       		scheme = "https"

     

       171
       171
       +
       	}

     

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

     

       173
       173
       +
       	xrpcc := &indigoxrpc.Client{

     

       174
       174
       +
       		Host: host,

     

       175
       175
       +
       	}

     

       176
       176
       +
       

     

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

     

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

     

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

     

       180
       180
       +
       		l.Error("failed to call XRPC repo.diff", "err", xrpcerr)

     

       181
       181
       +
       		rp.pages.Error503(w)

     

       182
       182
       +
       		return

     

       183
       183
       +
       	}

     

       184
       184
       +
       

     

       185
       185
       +
       	var result types.RepoCommitResponse

     

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

     

       187
       187
       +
       		l.Error("failed to decode XRPC response", "err", err)

     

       188
       188
       +
       		rp.pages.Error503(w)

     

       189
       189
       +
       		return

     

       190
       190
       +
       	}

     

       191
       191
       +
       

     

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

     

       193
       193
       +
       	if err != nil {

     

       194
       194
       +
       		l.Error("failed to get email to did mapping", "err", err)

     

       195
       195
       +
       	}

     

       196
       196
       +
       

     

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

     

       198
       198
       +
       	if err != nil {

     

       199
       199
       +
       		l.Error("failed to GetVerifiedCommits", "err", err)

     

       200
       200
       +
       	}

     

       201
       201
       +
       

     

       202
       202
       +
       	user := rp.oauth.GetUser(r)

     

       203
       203
       +
       	repoInfo := f.RepoInfo(user)

     

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

     

       205
       205
       +
       	if err != nil {

     

       206
       206
       +
       		l.Error("failed to getPipelineStatuses", "err", err)

     

       207
       207
       +
       		// non-fatal

     

       208
       208
       +
       	}

     

       209
       209
       +
       	var pipeline *models.Pipeline

     

       210
       210
       +
       	if p, ok := pipelines[result.Diff.Commit.This]; ok {

     

       211
       211
       +
       		pipeline = &p

     

       212
       212
       +
       	}

     

       213
       213
       +
       

     

       214
       214
       +
       	rp.pages.RepoCommit(w, pages.RepoCommitParams{

     

       215
       215
       +
       		LoggedInUser:       user,

     

       216
       216
       +
       		RepoInfo:           f.RepoInfo(user),

     

       217
       217
       +
       		RepoCommitResponse: result,

     

       218
       218
       +
       		EmailToDid:         emailToDidMap,

     

       219
       219
       +
       		VerifiedCommit:     vc,

     

       220
       220
       +
       		Pipeline:           pipeline,

     

       221
       221
       +
       		DiffOpts:           diffOpts,

     

       222
       222
       +
       	})

     

       223
       223
       +
       }

+1 -1

appview/repo/opengraph.go

···

       327
       327
        
       	return nil

     

       328
       328
        
       }

     

       329
       329
        
       

     

       330
       330
       -
       func (rp *Repo) RepoOpenGraphSummary(w http.ResponseWriter, r *http.Request) {

     

       330
       330
       +
       func (rp *Repo) Opengraph(w http.ResponseWriter, r *http.Request) {

     

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

     

       332
       332
        
       	if err != nil {

     

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

+71 -1439

appview/repo/repo.go

···

       3
       3
        
       import (

     

       4
       4
        
       	"context"

     

       5
       5
        
       	"database/sql"

     

       6
       6
       -
       	"encoding/json"

     

       7
       6
        
       	"errors"

     

       8
       7
        
       	"fmt"

     

       9
       9
       -
       	"io"

     

       10
       8
        
       	"log/slog"

     

       11
       9
        
       	"net/http"

     

       12
       10
        
       	"net/url"

     

       13
       13
       -
       	"path/filepath"

     

       14
       11
        
       	"slices"

     

       15
       15
       -
       	"strconv"

     

       16
       12
        
       	"strings"

     

       17
       13
        
       	"time"

     

       18
       14
        
       

     

       19
       15
        
       	"tangled.org/core/api/tangled"

     

       20
       20
       -
       	"tangled.org/core/appview/commitverify"

     

       21
       16
        
       	"tangled.org/core/appview/config"

     

       22
       17
        
       	"tangled.org/core/appview/db"

     

       23
       18
        
       	"tangled.org/core/appview/models"

     

       24
       19
        
       	"tangled.org/core/appview/notify"

     

       25
       20
        
       	"tangled.org/core/appview/oauth"

     

       26
       21
        
       	"tangled.org/core/appview/pages"

     

       27
       27
       -
       	"tangled.org/core/appview/pages/markup"

     

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

     

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

     

       30
       24
        
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       31
       25
        
       	"tangled.org/core/eventconsumer"

     

       32
       26
        
       	"tangled.org/core/idresolver"

     

       33
       33
       -
       	"tangled.org/core/patchutil"

     

       34
       27
        
       	"tangled.org/core/rbac"

     

       35
       28
        
       	"tangled.org/core/tid"

     

       36
       36
       -
       	"tangled.org/core/types"

     

       37
       29
        
       	"tangled.org/core/xrpc/serviceauth"

     

       38
       30
        
       

     

       39
       31
        
       	comatproto "github.com/bluesky-social/indigo/api/atproto"

     

       40
       32
        
       	atpclient "github.com/bluesky-social/indigo/atproto/client"

     

       41
       33
        
       	"github.com/bluesky-social/indigo/atproto/syntax"

     

       42
       34
        
       	lexutil "github.com/bluesky-social/indigo/lex/util"

     

       43
       43
       -
       	indigoxrpc "github.com/bluesky-social/indigo/xrpc"

     

       44
       35
        
       	securejoin "github.com/cyphar/filepath-securejoin"

     

       45
       36
        
       	"github.com/go-chi/chi/v5"

     

       46
       46
       -
       	"github.com/go-git/go-git/v5/plumbing"

     

       47
       37
        
       )

     

       48
       38
        
       

     

       49
       39
        
       type Repo struct {

     
···

       88
       78
        
       	}

     

       89
       79
        
       }

     

       90
       80
        
       

     

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

     

       92
       92
       -
       	l := rp.logger.With("handler", "DownloadArchive")

     

       93
       93
       -
       

     

       94
       94
       -
       	ref := chi.URLParam(r, "ref")

     

       95
       95
       -
       	ref, _ = url.PathUnescape(ref)

     

       96
       96
       -
       

     

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

     

       98
       98
       -
       	if err != nil {

     

       99
       99
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       100
       100
       -
       		return

     

       101
       101
       -
       	}

     

       102
       102
       -
       

     

       103
       103
       -
       	scheme := "http"

     

       104
       104
       -
       	if !rp.config.Core.Dev {

     

       105
       105
       -
       		scheme = "https"

     

       106
       106
       -
       	}

     

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

     

       108
       108
       -
       	xrpcc := &indigoxrpc.Client{

     

       109
       109
       -
       		Host: host,

     

       110
       110
       -
       	}

     

       111
       111
       -
       

     

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

     

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

     

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

     

       115
       115
       -
       		l.Error("failed to call XRPC repo.archive", "err", xrpcerr)

     

       116
       116
       -
       		rp.pages.Error503(w)

     

       117
       117
       -
       		return

     

       118
       118
       -
       	}

     

       119
       119
       -
       

     

       120
       120
       -
       	// Set headers for file download, just pass along whatever the knot specifies

     

       121
       121
       -
       	safeRefFilename := strings.ReplaceAll(plumbing.ReferenceName(ref).Short(), "/", "-")

     

       122
       122
       -
       	filename := fmt.Sprintf("%s-%s.tar.gz", f.Name, safeRefFilename)

     

       123
       123
       -
       	w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=\"%s\"", filename))

     

       124
       124
       -
       	w.Header().Set("Content-Type", "application/gzip")

     

       125
       125
       -
       	w.Header().Set("Content-Length", fmt.Sprintf("%d", len(archiveBytes)))

     

       126
       126
       -
       

     

       127
       127
       -
       	// Write the archive data directly

     

       128
       128
       -
       	w.Write(archiveBytes)

     

       129
       129
       -
       }

     

       130
       130
       -
       

     

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

     

       132
       132
       -
       	l := rp.logger.With("handler", "RepoLog")

     

       133
       133
       -
       

     

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

     

       135
       135
       -
       	if err != nil {

     

       136
       136
       -
       		l.Error("failed to fully resolve repo", "err", err)

     

       137
       137
       -
       		return

     

       138
       138
       -
       	}

     

       139
       139
       -
       

     

       140
       140
       -
       	page := 1

     

       141
       141
       -
       	if r.URL.Query().Get("page") != "" {

     

       142
       142
       -
       		page, err = strconv.Atoi(r.URL.Query().Get("page"))

     

       143
       143
       -
       		if err != nil {

     

       144
       144
       -
       			page = 1

     

       145
       145
       -
       		}

     

       146
       146
       -
       	}

     

       147
       147
       -
       

     

       148
       148
       -
       	ref := chi.URLParam(r, "ref")

     

       149
       149
       -
       	ref, _ = url.PathUnescape(ref)

     

       150
       150
       -
       

     

       151
       151
       -
       	scheme := "http"

     

       152
       152
       -
       	if !rp.config.Core.Dev {

     

       153
       153
       -
       		scheme = "https"

     

       154
       154
       -
       	}

     

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

     

       156
       156
       -
       	xrpcc := &indigoxrpc.Client{

     

       157
       157
       -
       		Host: host,

     

       158
       158
       -
       	}

     

       159
       159
       -
       

     

       160
       160
       -
       	limit := int64(60)

     

       161
       161
       -
       	cursor := ""

     

       162
       162
       -
       	if page > 1 {

     

       163
       163
       -
       		// Convert page number to cursor (offset)

     

       164
       164
       -
       		offset := (page - 1) * int(limit)

     

       165
       165
       -
       		cursor = strconv.Itoa(offset)

     

       166
       166
       -
       	}

     

       167
       167
       -
       

     

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

     

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

     

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

     

       171
       171
       -
       		l.Error("failed to call XRPC repo.log", "err", xrpcerr)

     

       172
       172
       -
       		rp.pages.Error503(w)

     

       173
       173
       -
       		return

     

       174
       174
       -
       	}

     

       175
       175
       -
       

     

       176
       176
       -
       	var xrpcResp types.RepoLogResponse

     

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

     

       178
       178
       -
       		l.Error("failed to decode XRPC response", "err", err)

     

       179
       179
       -
       		rp.pages.Error503(w)

     

       180
       180
       -
       		return

     

       181
       181
       -
       	}

     

       182
       182
       -
       

     

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

     

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

     

       185
       185
       -
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       186
       186
       -
       		rp.pages.Error503(w)

     

       187
       187
       -
       		return

     

       188
       188
       -
       	}

     

       189
       189
       -
       

     

       190
       190
       -
       	tagMap := make(map[string][]string)

     

       191
       191
       -
       	if tagBytes != nil {

     

       192
       192
       -
       		var tagResp types.RepoTagsResponse

     

       193
       193
       -
       		if err := json.Unmarshal(tagBytes, &tagResp); err == nil {

     

       194
       194
       -
       			for _, tag := range tagResp.Tags {

     

       195
       195
       -
       				hash := tag.Hash

     

       196
       196
       -
       				if tag.Tag != nil {

     

       197
       197
       -
       					hash = tag.Tag.Target.String()

     

       198
       198
       -
       				}

     

       199
       199
       -
       				tagMap[hash] = append(tagMap[hash], tag.Name)

     

       200
       200
       -
       			}

     

       201
       201
       -
       		}

     

       202
       202
       -
       	}

     

       203
       203
       -
       

     

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

     

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

     

       206
       206
       -
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       207
       207
       -
       		rp.pages.Error503(w)

     

       208
       208
       -
       		return

     

       209
       209
       -
       	}

     

       210
       210
       -
       

     

       211
       211
       -
       	if branchBytes != nil {

     

       212
       212
       -
       		var branchResp types.RepoBranchesResponse

     

       213
       213
       -
       		if err := json.Unmarshal(branchBytes, &branchResp); err == nil {

     

       214
       214
       -
       			for _, branch := range branchResp.Branches {

     

       215
       215
       -
       				tagMap[branch.Hash] = append(tagMap[branch.Hash], branch.Name)

     

       216
       216
       -
       			}

     

       217
       217
       -
       		}

     

       218
       218
       -
       	}

     

       219
       219
       -
       

     

       220
       220
       -
       	user := rp.oauth.GetUser(r)

     

       221
       221
       -
       

     

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

     

       223
       223
       -
       	if err != nil {

     

       224
       224
       -
       		l.Error("failed to fetch email to did mapping", "err", err)

     

       225
       225
       -
       	}

     

       226
       226
       -
       

     

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

     

       228
       228
       -
       	if err != nil {

     

       229
       229
       -
       		l.Error("failed to GetVerifiedObjectCommits", "err", err)

     

       230
       230
       -
       	}

     

       231
       231
       -
       

     

       232
       232
       -
       	repoInfo := f.RepoInfo(user)

     

       233
       233
       -
       

     

       234
       234
       -
       	var shas []string

     

       235
       235
       -
       	for _, c := range xrpcResp.Commits {

     

       236
       236
       -
       		shas = append(shas, c.Hash.String())

     

       237
       237
       -
       	}

     

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

     

       239
       239
       -
       	if err != nil {

     

       240
       240
       -
       		l.Error("failed to getPipelineStatuses", "err", err)

     

       241
       241
       -
       		// non-fatal

     

       242
       242
       -
       	}

     

       243
       243
       -
       

     

       244
       244
       -
       	rp.pages.RepoLog(w, pages.RepoLogParams{

     

       245
       245
       -
       		LoggedInUser:    user,

     

       246
       246
       -
       		TagMap:          tagMap,

     

       247
       247
       -
       		RepoInfo:        repoInfo,

     

       248
       248
       -
       		RepoLogResponse: xrpcResp,

     

       249
       249
       -
       		EmailToDid:      emailToDidMap,

     

       250
       250
       -
       		VerifiedCommits: vc,

     

       251
       251
       -
       		Pipelines:       pipelines,

     

       252
       252
       -
       	})

     

       253
       253
       -
       }

     

       254
       254
       -
       

     

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

     

       256
       256
       -
       	l := rp.logger.With("handler", "RepoCommit")

     

       257
       257
       -
       

     

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

     

       259
       259
       -
       	if err != nil {

     

       260
       260
       -
       		l.Error("failed to fully resolve repo", "err", err)

     

       261
       261
       -
       		return

     

       262
       262
       -
       	}

     

       263
       263
       -
       	ref := chi.URLParam(r, "ref")

     

       264
       264
       -
       	ref, _ = url.PathUnescape(ref)

     

       265
       265
       -
       

     

       266
       266
       -
       	var diffOpts types.DiffOpts

     

       267
       267
       -
       	if d := r.URL.Query().Get("diff"); d == "split" {

     

       268
       268
       -
       		diffOpts.Split = true

     

       269
       269
       -
       	}

     

       270
       270
       -
       

     

       271
       271
       -
       	if !plumbing.IsHash(ref) {

     

       272
       272
       -
       		rp.pages.Error404(w)

     

       273
       273
       -
       		return

     

       274
       274
       -
       	}

     

       275
       275
       -
       

     

       276
       276
       -
       	scheme := "http"

     

       277
       277
       -
       	if !rp.config.Core.Dev {

     

       278
       278
       -
       		scheme = "https"

     

       279
       279
       -
       	}

     

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

     

       281
       281
       -
       	xrpcc := &indigoxrpc.Client{

     

       282
       282
       -
       		Host: host,

     

       283
       283
       -
       	}

     

       284
       284
       -
       

     

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

     

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

     

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

     

       288
       288
       -
       		l.Error("failed to call XRPC repo.diff", "err", xrpcerr)

     

       289
       289
       -
       		rp.pages.Error503(w)

     

       290
       290
       -
       		return

     

       291
       291
       -
       	}

     

       292
       292
       -
       

     

       293
       293
       -
       	var result types.RepoCommitResponse

     

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

     

       295
       295
       -
       		l.Error("failed to decode XRPC response", "err", err)

     

       296
       296
       -
       		rp.pages.Error503(w)

     

       297
       297
       -
       		return

     

       298
       298
       -
       	}

     

       299
       299
       -
       

     

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

     

       301
       301
       -
       	if err != nil {

     

       302
       302
       -
       		l.Error("failed to get email to did mapping", "err", err)

     

       303
       303
       -
       	}

     

       304
       304
       -
       

     

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

     

       306
       306
       -
       	if err != nil {

     

       307
       307
       -
       		l.Error("failed to GetVerifiedCommits", "err", err)

     

       308
       308
       -
       	}

     

       309
       309
       -
       

     

       310
       310
       -
       	user := rp.oauth.GetUser(r)

     

       311
       311
       -
       	repoInfo := f.RepoInfo(user)

     

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

     

       313
       313
       -
       	if err != nil {

     

       314
       314
       -
       		l.Error("failed to getPipelineStatuses", "err", err)

     

       315
       315
       -
       		// non-fatal

     

       316
       316
       -
       	}

     

       317
       317
       -
       	var pipeline *models.Pipeline

     

       318
       318
       -
       	if p, ok := pipelines[result.Diff.Commit.This]; ok {

     

       319
       319
       -
       		pipeline = &p

     

       320
       320
       -
       	}

     

       321
       321
       -
       

     

       322
       322
       -
       	rp.pages.RepoCommit(w, pages.RepoCommitParams{

     

       323
       323
       -
       		LoggedInUser:       user,

     

       324
       324
       -
       		RepoInfo:           f.RepoInfo(user),

     

       325
       325
       -
       		RepoCommitResponse: result,

     

       326
       326
       -
       		EmailToDid:         emailToDidMap,

     

       327
       327
       -
       		VerifiedCommit:     vc,

     

       328
       328
       -
       		Pipeline:           pipeline,

     

       329
       329
       -
       		DiffOpts:           diffOpts,

     

       330
       330
       -
       	})

     

       331
       331
       -
       }

     

       332
       332
       -
       

     

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

     

       334
       334
       -
       	l := rp.logger.With("handler", "RepoTree")

     

       335
       335
       -
       

     

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

     

       337
       337
       -
       	if err != nil {

     

       338
       338
       -
       		l.Error("failed to fully resolve repo", "err", err)

     

       339
       339
       -
       		return

     

       340
       340
       -
       	}

     

       341
       341
       -
       

     

       342
       342
       -
       	ref := chi.URLParam(r, "ref")

     

       343
       343
       -
       	ref, _ = url.PathUnescape(ref)

     

       344
       344
       -
       

     

       345
       345
       -
       	// if the tree path has a trailing slash, let's strip it

     

       346
       346
       -
       	// so we don't 404

     

       347
       347
       -
       	treePath := chi.URLParam(r, "*")

     

       348
       348
       -
       	treePath, _ = url.PathUnescape(treePath)

     

       349
       349
       -
       	treePath = strings.TrimSuffix(treePath, "/")

     

       350
       350
       -
       

     

       351
       351
       -
       	scheme := "http"

     

       352
       352
       -
       	if !rp.config.Core.Dev {

     

       353
       353
       -
       		scheme = "https"

     

       354
       354
       -
       	}

     

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

     

       356
       356
       -
       	xrpcc := &indigoxrpc.Client{

     

       357
       357
       -
       		Host: host,

     

       358
       358
       -
       	}

     

       359
       359
       -
       

     

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

     

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

     

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

     

       363
       363
       -
       		l.Error("failed to call XRPC repo.tree", "err", xrpcerr)

     

       364
       364
       -
       		rp.pages.Error503(w)

     

       365
       365
       -
       		return

     

       366
       366
       -
       	}

     

       367
       367
       -
       

     

       368
       368
       -
       	// Convert XRPC response to internal types.RepoTreeResponse

     

       369
       369
       -
       	files := make([]types.NiceTree, len(xrpcResp.Files))

     

       370
       370
       -
       	for i, xrpcFile := range xrpcResp.Files {

     

       371
       371
       -
       		file := types.NiceTree{

     

       372
       372
       -
       			Name:      xrpcFile.Name,

     

       373
       373
       -
       			Mode:      xrpcFile.Mode,

     

       374
       374
       -
       			Size:      int64(xrpcFile.Size),

     

       375
       375
       -
       			IsFile:    xrpcFile.Is_file,

     

       376
       376
       -
       			IsSubtree: xrpcFile.Is_subtree,

     

       377
       377
       -
       		}

     

       378
       378
       -
       

     

       379
       379
       -
       		// Convert last commit info if present

     

       380
       380
       -
       		if xrpcFile.Last_commit != nil {

     

       381
       381
       -
       			commitWhen, _ := time.Parse(time.RFC3339, xrpcFile.Last_commit.When)

     

       382
       382
       -
       			file.LastCommit = &types.LastCommitInfo{

     

       383
       383
       -
       				Hash:    plumbing.NewHash(xrpcFile.Last_commit.Hash),

     

       384
       384
       -
       				Message: xrpcFile.Last_commit.Message,

     

       385
       385
       -
       				When:    commitWhen,

     

       386
       386
       -
       			}

     

       387
       387
       -
       		}

     

       388
       388
       -
       

     

       389
       389
       -
       		files[i] = file

     

       390
       390
       -
       	}

     

       391
       391
       -
       

     

       392
       392
       -
       	result := types.RepoTreeResponse{

     

       393
       393
       -
       		Ref:   xrpcResp.Ref,

     

       394
       394
       -
       		Files: files,

     

       395
       395
       -
       	}

     

       396
       396
       -
       

     

       397
       397
       -
       	if xrpcResp.Parent != nil {

     

       398
       398
       -
       		result.Parent = *xrpcResp.Parent

     

       399
       399
       -
       	}

     

       400
       400
       -
       	if xrpcResp.Dotdot != nil {

     

       401
       401
       -
       		result.DotDot = *xrpcResp.Dotdot

     

       402
       402
       -
       	}

     

       403
       403
       -
       	if xrpcResp.Readme != nil {

     

       404
       404
       -
       		result.ReadmeFileName = xrpcResp.Readme.Filename

     

       405
       405
       -
       		result.Readme = xrpcResp.Readme.Contents

     

       406
       406
       -
       	}

     

       407
       407
       -
       

     

       408
       408
       -
       	// redirects tree paths trying to access a blob; in this case the result.Files is unpopulated,

     

       409
       409
       -
       	// so we can safely redirect to the "parent" (which is the same file).

     

       410
       410
       -
       	if len(result.Files) == 0 && result.Parent == treePath {

     

       411
       411
       -
       		redirectTo := fmt.Sprintf("/%s/blob/%s/%s", f.OwnerSlashRepo(), url.PathEscape(ref), result.Parent)

     

       412
       412
       -
       		http.Redirect(w, r, redirectTo, http.StatusFound)

     

       413
       413
       -
       		return

     

       414
       414
       -
       	}

     

       415
       415
       -
       

     

       416
       416
       -
       	user := rp.oauth.GetUser(r)

     

       417
       417
       -
       

     

       418
       418
       -
       	var breadcrumbs [][]string

     

       419
       419
       -
       	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})

     

       420
       420
       -
       	if treePath != "" {

     

       421
       421
       -
       		for idx, elem := range strings.Split(treePath, "/") {

     

       422
       422
       -
       			breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], url.PathEscape(elem))})

     

       423
       423
       -
       		}

     

       424
       424
       -
       	}

     

       425
       425
       -
       

     

       426
       426
       -
       	sortFiles(result.Files)

     

       427
       427
       -
       

     

       428
       428
       -
       	rp.pages.RepoTree(w, pages.RepoTreeParams{

     

       429
       429
       -
       		LoggedInUser:     user,

     

       430
       430
       -
       		BreadCrumbs:      breadcrumbs,

     

       431
       431
       -
       		TreePath:         treePath,

     

       432
       432
       -
       		RepoInfo:         f.RepoInfo(user),

     

       433
       433
       -
       		RepoTreeResponse: result,

     

       434
       434
       -
       	})

     

       435
       435
       -
       }

     

       436
       436
       -
       

     

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

     

       438
       438
       -
       	l := rp.logger.With("handler", "RepoTags")

     

       439
       439
       -
       

     

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

     

       441
       441
       -
       	if err != nil {

     

       442
       442
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       443
       443
       -
       		return

     

       444
       444
       -
       	}

     

       445
       445
       -
       

     

       446
       446
       -
       	scheme := "http"

     

       447
       447
       -
       	if !rp.config.Core.Dev {

     

       448
       448
       -
       		scheme = "https"

     

       449
       449
       -
       	}

     

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

     

       451
       451
       -
       	xrpcc := &indigoxrpc.Client{

     

       452
       452
       -
       		Host: host,

     

       453
       453
       -
       	}

     

       454
       454
       -
       

     

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

     

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

     

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

     

       458
       458
       -
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       459
       459
       -
       		rp.pages.Error503(w)

     

       460
       460
       -
       		return

     

       461
       461
       -
       	}

     

       462
       462
       -
       

     

       463
       463
       -
       	var result types.RepoTagsResponse

     

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

     

       465
       465
       -
       		l.Error("failed to decode XRPC response", "err", err)

     

       466
       466
       -
       		rp.pages.Error503(w)

     

       467
       467
       -
       		return

     

       468
       468
       -
       	}

     

       469
       469
       -
       

     

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

     

       471
       471
       -
       	if err != nil {

     

       472
       472
       -
       		l.Error("failed grab artifacts", "err", err)

     

       473
       473
       -
       		return

     

       474
       474
       -
       	}

     

       475
       475
       -
       

     

       476
       476
       -
       	// convert artifacts to map for easy UI building

     

       477
       477
       -
       	artifactMap := make(map[plumbing.Hash][]models.Artifact)

     

       478
       478
       -
       	for _, a := range artifacts {

     

       479
       479
       -
       		artifactMap[a.Tag] = append(artifactMap[a.Tag], a)

     

       480
       480
       -
       	}

     

       481
       481
       -
       

     

       482
       482
       -
       	var danglingArtifacts []models.Artifact

     

       483
       483
       -
       	for _, a := range artifacts {

     

       484
       484
       -
       		found := false

     

       485
       485
       -
       		for _, t := range result.Tags {

     

       486
       486
       -
       			if t.Tag != nil {

     

       487
       487
       -
       				if t.Tag.Hash == a.Tag {

     

       488
       488
       -
       					found = true

     

       489
       489
       -
       				}

     

       490
       490
       -
       			}

     

       491
       491
       -
       		}

     

       492
       492
       -
       

     

       493
       493
       -
       		if !found {

     

       494
       494
       -
       			danglingArtifacts = append(danglingArtifacts, a)

     

       495
       495
       -
       		}

     

       496
       496
       -
       	}

     

       497
       497
       -
       

     

       498
       498
       -
       	user := rp.oauth.GetUser(r)

     

       499
       499
       -
       	rp.pages.RepoTags(w, pages.RepoTagsParams{

     

       500
       500
       -
       		LoggedInUser:      user,

     

       501
       501
       -
       		RepoInfo:          f.RepoInfo(user),

     

       502
       502
       -
       		RepoTagsResponse:  result,

     

       503
       503
       -
       		ArtifactMap:       artifactMap,

     

       504
       504
       -
       		DanglingArtifacts: danglingArtifacts,

     

       505
       505
       -
       	})

     

       506
       506
       -
       }

     

       507
       507
       -
       

     

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

     

       509
       509
       -
       	l := rp.logger.With("handler", "RepoBranches")

     

       510
       510
       -
       

     

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

     

       512
       512
       -
       	if err != nil {

     

       513
       513
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       514
       514
       -
       		return

     

       515
       515
       -
       	}

     

       516
       516
       -
       

     

       517
       517
       -
       	scheme := "http"

     

       518
       518
       -
       	if !rp.config.Core.Dev {

     

       519
       519
       -
       		scheme = "https"

     

       520
       520
       -
       	}

     

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

     

       522
       522
       -
       	xrpcc := &indigoxrpc.Client{

     

       523
       523
       -
       		Host: host,

     

       524
       524
       -
       	}

     

       525
       525
       -
       

     

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

     

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

     

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

     

       529
       529
       -
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       530
       530
       -
       		rp.pages.Error503(w)

     

       531
       531
       -
       		return

     

       532
       532
       -
       	}

     

       533
       533
       -
       

     

       534
       534
       -
       	var result types.RepoBranchesResponse

     

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

     

       536
       536
       -
       		l.Error("failed to decode XRPC response", "err", err)

     

       537
       537
       -
       		rp.pages.Error503(w)

     

       538
       538
       -
       		return

     

       539
       539
       -
       	}

     

       540
       540
       -
       

     

       541
       541
       -
       	sortBranches(result.Branches)

     

       542
       542
       -
       

     

       543
       543
       -
       	user := rp.oauth.GetUser(r)

     

       544
       544
       -
       	rp.pages.RepoBranches(w, pages.RepoBranchesParams{

     

       545
       545
       -
       		LoggedInUser:         user,

     

       546
       546
       -
       		RepoInfo:             f.RepoInfo(user),

     

       547
       547
       -
       		RepoBranchesResponse: result,

     

       548
       548
       -
       	})

     

       549
       549
       -
       }

     

       550
       550
       -
       

     

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

     

       552
       552
       -
       	l := rp.logger.With("handler", "DeleteBranch")

     

       553
       553
       -
       

     

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

     

       555
       555
       -
       	if err != nil {

     

       556
       556
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       557
       557
       -
       		return

     

       558
       558
       -
       	}

     

       559
       559
       -
       

     

       560
       560
       -
       	noticeId := "delete-branch-error"

     

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

     

       562
       562
       -
       		l.Error(msg, "err", err)

     

       563
       563
       -
       		rp.pages.Notice(w, noticeId, msg)

     

       564
       564
       -
       	}

     

       565
       565
       -
       

     

       566
       566
       -
       	branch := r.FormValue("branch")

     

       567
       567
       -
       	if branch == "" {

     

       568
       568
       -
       		fail("No branch provided.", nil)

     

       569
       569
       -
       		return

     

       570
       570
       -
       	}

     

       571
       571
       -
       

     

       572
       572
       -
       	client, err := rp.oauth.ServiceClient(

     

       573
       573
       -
       		r,

     

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

     

       575
       575
       -
       		oauth.WithLxm(tangled.RepoDeleteBranchNSID),

     

       576
       576
       -
       		oauth.WithDev(rp.config.Core.Dev),

     

       577
       577
       -
       	)

     

       578
       578
       -
       	if err != nil {

     

       579
       579
       -
       		fail("Failed to connect to knotserver", nil)

     

       580
       580
       -
       		return

     

       581
       581
       -
       	}

     

       582
       582
       -
       

     

       583
       583
       -
       	err = tangled.RepoDeleteBranch(

     

       584
       584
       -
       		r.Context(),

     

       585
       585
       -
       		client,

     

       586
       586
       -
       		&tangled.RepoDeleteBranch_Input{

     

       587
       587
       -
       			Branch: branch,

     

       588
       588
       -
       			Repo:   f.RepoAt().String(),

     

       589
       589
       -
       		},

     

       590
       590
       -
       	)

     

       591
       591
       -
       	if err := xrpcclient.HandleXrpcErr(err); err != nil {

     

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

     

       593
       593
       -
       		return

     

       594
       594
       -
       	}

     

       595
       595
       -
       	l.Error("deleted branch from knot", "branch", branch, "repo", f.RepoAt())

     

       596
       596
       -
       

     

       597
       597
       -
       	rp.pages.HxRefresh(w)

     

       598
       598
       -
       }

     

       599
       599
       -
       

     

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

     

       601
       601
       -
       	l := rp.logger.With("handler", "RepoBlob")

     

       602
       602
       -
       

     

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

     

       604
       604
       -
       	if err != nil {

     

       605
       605
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       606
       606
       -
       		return

     

       607
       607
       -
       	}

     

       608
       608
       -
       

     

       609
       609
       -
       	ref := chi.URLParam(r, "ref")

     

       610
       610
       -
       	ref, _ = url.PathUnescape(ref)

     

       611
       611
       -
       

     

       612
       612
       -
       	filePath := chi.URLParam(r, "*")

     

       613
       613
       -
       	filePath, _ = url.PathUnescape(filePath)

     

       614
       614
       -
       

     

       615
       615
       -
       	scheme := "http"

     

       616
       616
       -
       	if !rp.config.Core.Dev {

     

       617
       617
       -
       		scheme = "https"

     

       618
       618
       -
       	}

     

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

     

       620
       620
       -
       	xrpcc := &indigoxrpc.Client{

     

       621
       621
       -
       		Host: host,

     

       622
       622
       -
       	}

     

       623
       623
       -
       

     

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

     

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

     

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

     

       627
       627
       -
       		l.Error("failed to call XRPC repo.blob", "err", xrpcerr)

     

       628
       628
       -
       		rp.pages.Error503(w)

     

       629
       629
       -
       		return

     

       630
       630
       -
       	}

     

       631
       631
       -
       

     

       632
       632
       -
       	// Use XRPC response directly instead of converting to internal types

     

       633
       633
       -
       

     

       634
       634
       -
       	var breadcrumbs [][]string

     

       635
       635
       -
       	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})

     

       636
       636
       -
       	if filePath != "" {

     

       637
       637
       -
       		for idx, elem := range strings.Split(filePath, "/") {

     

       638
       638
       -
       			breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], url.PathEscape(elem))})

     

       639
       639
       -
       		}

     

       640
       640
       -
       	}

     

       641
       641
       -
       

     

       642
       642
       -
       	showRendered := false

     

       643
       643
       -
       	renderToggle := false

     

       644
       644
       -
       

     

       645
       645
       -
       	if markup.GetFormat(resp.Path) == markup.FormatMarkdown {

     

       646
       646
       -
       		renderToggle = true

     

       647
       647
       -
       		showRendered = r.URL.Query().Get("code") != "true"

     

       648
       648
       -
       	}

     

       649
       649
       -
       

     

       650
       650
       -
       	var unsupported bool

     

       651
       651
       -
       	var isImage bool

     

       652
       652
       -
       	var isVideo bool

     

       653
       653
       -
       	var contentSrc string

     

       654
       654
       -
       

     

       655
       655
       -
       	if resp.IsBinary != nil && *resp.IsBinary {

     

       656
       656
       -
       		ext := strings.ToLower(filepath.Ext(resp.Path))

     

       657
       657
       -
       		switch ext {

     

       658
       658
       -
       		case ".jpg", ".jpeg", ".png", ".gif", ".svg", ".webp":

     

       659
       659
       -
       			isImage = true

     

       660
       660
       -
       		case ".mp4", ".webm", ".ogg", ".mov", ".avi":

     

       661
       661
       -
       			isVideo = true

     

       662
       662
       -
       		default:

     

       663
       663
       -
       			unsupported = true

     

       664
       664
       -
       		}

     

       665
       665
       -
       

     

       666
       666
       -
       		// fetch the raw binary content using sh.tangled.repo.blob xrpc

     

       667
       667
       -
       		repoName := fmt.Sprintf("%s/%s", f.OwnerDid(), f.Name)

     

       668
       668
       -
       

     

       669
       669
       -
       		baseURL := &url.URL{

     

       670
       670
       -
       			Scheme: scheme,

     

       671
       671
       -
       			Host:   f.Knot,

     

       672
       672
       -
       			Path:   "/xrpc/sh.tangled.repo.blob",

     

       673
       673
       -
       		}

     

       674
       674
       -
       		query := baseURL.Query()

     

       675
       675
       -
       		query.Set("repo", repoName)

     

       676
       676
       -
       		query.Set("ref", ref)

     

       677
       677
       -
       		query.Set("path", filePath)

     

       678
       678
       -
       		query.Set("raw", "true")

     

       679
       679
       -
       		baseURL.RawQuery = query.Encode()

     

       680
       680
       -
       		blobURL := baseURL.String()

     

       681
       681
       -
       

     

       682
       682
       -
       		contentSrc = blobURL

     

       683
       683
       -
       		if !rp.config.Core.Dev {

     

       684
       684
       -
       			contentSrc = markup.GenerateCamoURL(rp.config.Camo.Host, rp.config.Camo.SharedSecret, blobURL)

     

       685
       685
       -
       		}

     

       686
       686
       -
       	}

     

       687
       687
       -
       

     

       688
       688
       -
       	lines := 0

     

       689
       689
       -
       	if resp.IsBinary == nil || !*resp.IsBinary {

     

       690
       690
       -
       		lines = strings.Count(resp.Content, "\n") + 1

     

       691
       691
       -
       	}

     

       692
       692
       -
       

     

       693
       693
       -
       	var sizeHint uint64

     

       694
       694
       -
       	if resp.Size != nil {

     

       695
       695
       -
       		sizeHint = uint64(*resp.Size)

     

       696
       696
       -
       	} else {

     

       697
       697
       -
       		sizeHint = uint64(len(resp.Content))

     

       698
       698
       -
       	}

     

       699
       699
       -
       

     

       700
       700
       -
       	user := rp.oauth.GetUser(r)

     

       701
       701
       -
       

     

       702
       702
       -
       	// Determine if content is binary (dereference pointer)

     

       703
       703
       -
       	isBinary := false

     

       704
       704
       -
       	if resp.IsBinary != nil {

     

       705
       705
       -
       		isBinary = *resp.IsBinary

     

       706
       706
       -
       	}

     

       707
       707
       -
       

     

       708
       708
       -
       	rp.pages.RepoBlob(w, pages.RepoBlobParams{

     

       709
       709
       -
       		LoggedInUser:    user,

     

       710
       710
       -
       		RepoInfo:        f.RepoInfo(user),

     

       711
       711
       -
       		BreadCrumbs:     breadcrumbs,

     

       712
       712
       -
       		ShowRendered:    showRendered,

     

       713
       713
       -
       		RenderToggle:    renderToggle,

     

       714
       714
       -
       		Unsupported:     unsupported,

     

       715
       715
       -
       		IsImage:         isImage,

     

       716
       716
       -
       		IsVideo:         isVideo,

     

       717
       717
       -
       		ContentSrc:      contentSrc,

     

       718
       718
       -
       		RepoBlob_Output: resp,

     

       719
       719
       -
       		Contents:        resp.Content,

     

       720
       720
       -
       		Lines:           lines,

     

       721
       721
       -
       		SizeHint:        sizeHint,

     

       722
       722
       -
       		IsBinary:        isBinary,

     

       723
       723
       -
       	})

     

       724
       724
       -
       }

     

       725
       725
       -
       

     

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

     

       727
       727
       -
       	l := rp.logger.With("handler", "RepoBlobRaw")

     

       728
       728
       -
       

     

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

     

       730
       730
       -
       	if err != nil {

     

       731
       731
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       732
       732
       -
       		w.WriteHeader(http.StatusBadRequest)

     

       733
       733
       -
       		return

     

       734
       734
       -
       	}

     

       735
       735
       -
       

     

       736
       736
       -
       	ref := chi.URLParam(r, "ref")

     

       737
       737
       -
       	ref, _ = url.PathUnescape(ref)

     

       738
       738
       -
       

     

       739
       739
       -
       	filePath := chi.URLParam(r, "*")

     

       740
       740
       -
       	filePath, _ = url.PathUnescape(filePath)

     

       741
       741
       -
       

     

       742
       742
       -
       	scheme := "http"

     

       743
       743
       -
       	if !rp.config.Core.Dev {

     

       744
       744
       -
       		scheme = "https"

     

       745
       745
       -
       	}

     

       746
       746
       -
       

     

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

     

       748
       748
       -
       	baseURL := &url.URL{

     

       749
       749
       -
       		Scheme: scheme,

     

       750
       750
       -
       		Host:   f.Knot,

     

       751
       751
       -
       		Path:   "/xrpc/sh.tangled.repo.blob",

     

       752
       752
       -
       	}

     

       753
       753
       -
       	query := baseURL.Query()

     

       754
       754
       -
       	query.Set("repo", repo)

     

       755
       755
       -
       	query.Set("ref", ref)

     

       756
       756
       -
       	query.Set("path", filePath)

     

       757
       757
       -
       	query.Set("raw", "true")

     

       758
       758
       -
       	baseURL.RawQuery = query.Encode()

     

       759
       759
       -
       	blobURL := baseURL.String()

     

       760
       760
       -
       

     

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

     

       762
       762
       -
       	if err != nil {

     

       763
       763
       -
       		l.Error("failed to create request", "err", err)

     

       764
       764
       -
       		return

     

       765
       765
       -
       	}

     

       766
       766
       -
       

     

       767
       767
       -
       	// forward the If-None-Match header

     

       768
       768
       -
       	if clientETag := r.Header.Get("If-None-Match"); clientETag != "" {

     

       769
       769
       -
       		req.Header.Set("If-None-Match", clientETag)

     

       770
       770
       -
       	}

     

       771
       771
       -
       

     

       772
       772
       -
       	client := &http.Client{}

     

       773
       773
       -
       	resp, err := client.Do(req)

     

       774
       774
       -
       	if err != nil {

     

       775
       775
       -
       		l.Error("failed to reach knotserver", "err", err)

     

       776
       776
       -
       		rp.pages.Error503(w)

     

       777
       777
       -
       		return

     

       778
       778
       -
       	}

     

       779
       779
       -
       	defer resp.Body.Close()

     

       780
       780
       -
       

     

       781
       781
       -
       	// forward 304 not modified

     

       782
       782
       -
       	if resp.StatusCode == http.StatusNotModified {

     

       783
       783
       -
       		w.WriteHeader(http.StatusNotModified)

     

       784
       784
       -
       		return

     

       785
       785
       -
       	}

     

       786
       786
       -
       

     

       787
       787
       -
       	if resp.StatusCode != http.StatusOK {

     

       788
       788
       -
       		l.Error("knotserver returned non-OK status for raw blob", "url", blobURL, "statuscode", resp.StatusCode)

     

       789
       789
       -
       		w.WriteHeader(resp.StatusCode)

     

       790
       790
       -
       		_, _ = io.Copy(w, resp.Body)

     

       791
       791
       -
       		return

     

       792
       792
       -
       	}

     

       793
       793
       -
       

     

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

     

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

     

       796
       796
       -
       	if err != nil {

     

       797
       797
       -
       		l.Error("error reading response body from knotserver", "err", err)

     

       798
       798
       -
       		w.WriteHeader(http.StatusInternalServerError)

     

       799
       799
       -
       		return

     

       800
       800
       -
       	}

     

       801
       801
       -
       

     

       802
       802
       -
       	if strings.HasPrefix(contentType, "text/") || isTextualMimeType(contentType) {

     

       803
       803
       -
       		// serve all textual content as text/plain

     

       804
       804
       -
       		w.Header().Set("Content-Type", "text/plain; charset=utf-8")

     

       805
       805
       -
       		w.Write(body)

     

       806
       806
       -
       	} else if strings.HasPrefix(contentType, "image/") || strings.HasPrefix(contentType, "video/") {

     

       807
       807
       -
       		// serve images and videos with their original content type

     

       808
       808
       -
       		w.Header().Set("Content-Type", contentType)

     

       809
       809
       -
       		w.Write(body)

     

       810
       810
       -
       	} else {

     

       811
       811
       -
       		w.WriteHeader(http.StatusUnsupportedMediaType)

     

       812
       812
       -
       		w.Write([]byte("unsupported content type"))

     

       813
       813
       -
       		return

     

       814
       814
       -
       	}

     

       815
       815
       -
       }

     

       816
       816
       -
       

     

       817
       81
        
       // isTextualMimeType returns true if the MIME type represents textual content

     

       818
       818
       -
       // that should be served as text/plain

     

       819
       819
       -
       func isTextualMimeType(mimeType string) bool {

     

       820
       820
       -
       	textualTypes := []string{

     

       821
       821
       -
       		"application/json",

     

       822
       822
       -
       		"application/xml",

     

       823
       823
       -
       		"application/yaml",

     

       824
       824
       -
       		"application/x-yaml",

     

       825
       825
       -
       		"application/toml",

     

       826
       826
       -
       		"application/javascript",

     

       827
       827
       -
       		"application/ecmascript",

     

       828
       828
       -
       		"message/",

     

       829
       829
       -
       	}

     

       830
       830
       -
       

     

       831
       831
       -
       	return slices.Contains(textualTypes, mimeType)

     

       832
       832
       -
       }

     

       833
       82
        
       

     

       834
       83
        
       // modify the spindle configured for this repo

     

       835
       84
        
       func (rp *Repo) EditSpindle(w http.ResponseWriter, r *http.Request) {

     
···

       1548
       797
        
       		Rkey:       rkey,

     

       1549
       798
        
       		SubjectDid: collaboratorIdent.DID,

     

       1550
       799
        
       		RepoAt:     f.RepoAt(),

     

       1551
       1551
       -
       		Created:    createdAt,

     

       1552
       1552
       -
       	})

     

       1553
       1553
       -
       	if err != nil {

     

       1554
       1554
       -
       		fail("Failed to add collaborator.", err)

     

       1555
       1555
       -
       		return

     

       1556
       1556
       -
       	}

     

       1557
       1557
       -
       

     

       1558
       1558
       -
       	err = tx.Commit()

     

       1559
       1559
       -
       	if err != nil {

     

       1560
       1560
       -
       		fail("Failed to add collaborator.", err)

     

       1561
       1561
       -
       		return

     

       1562
       1562
       -
       	}

     

       1563
       1563
       -
       

     

       1564
       1564
       -
       	err = rp.enforcer.E.SavePolicy()

     

       1565
       1565
       -
       	if err != nil {

     

       1566
       1566
       -
       		fail("Failed to update collaborator permissions.", err)

     

       1567
       1567
       -
       		return

     

       1568
       1568
       -
       	}

     

       1569
       1569
       -
       

     

       1570
       1570
       -
       	// clear aturi to when everything is successful

     

       1571
       1571
       -
       	aturi = ""

     

       1572
       1572
       -
       

     

       1573
       1573
       -
       	rp.pages.HxRefresh(w)

     

       1574
       1574
       -
       }

     

       1575
       1575
       -
       

     

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

     

       1577
       1577
       -
       	user := rp.oauth.GetUser(r)

     

       1578
       1578
       -
       	l := rp.logger.With("handler", "DeleteRepo")

     

       1579
       1579
       -
       

     

       1580
       1580
       -
       	noticeId := "operation-error"

     

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

     

       1582
       1582
       -
       	if err != nil {

     

       1583
       1583
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       1584
       1584
       -
       		return

     

       1585
       1585
       -
       	}

     

       1586
       1586
       -
       

     

       1587
       1587
       -
       	// remove record from pds

     

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

     

       1589
       1589
       -
       	if err != nil {

     

       1590
       1590
       -
       		l.Error("failed to get authorized client", "err", err)

     

       1591
       1591
       -
       		return

     

       1592
       1592
       -
       	}

     

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

     

       1594
       1594
       -
       		Collection: tangled.RepoNSID,

     

       1595
       1595
       -
       		Repo:       user.Did,

     

       1596
       1596
       -
       		Rkey:       f.Rkey,

     

       1597
       1597
       -
       	})

     

       1598
       1598
       -
       	if err != nil {

     

       1599
       1599
       -
       		l.Error("failed to delete record", "err", err)

     

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

     

       1601
       1601
       -
       		return

     

       1602
       1602
       -
       	}

     

       1603
       1603
       -
       	l.Info("removed repo record", "aturi", f.RepoAt().String())

     

       1604
       1604
       -
       

     

       1605
       1605
       -
       	client, err := rp.oauth.ServiceClient(

     

       1606
       1606
       -
       		r,

     

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

     

       1608
       1608
       -
       		oauth.WithLxm(tangled.RepoDeleteNSID),

     

       1609
       1609
       -
       		oauth.WithDev(rp.config.Core.Dev),

     

       1610
       1610
       -
       	)

     

       1611
       1611
       -
       	if err != nil {

     

       1612
       1612
       -
       		l.Error("failed to connect to knot server", "err", err)

     

       1613
       1613
       -
       		return

     

       1614
       1614
       -
       	}

     

       1615
       1615
       -
       

     

       1616
       1616
       -
       	err = tangled.RepoDelete(

     

       1617
       1617
       -
       		r.Context(),

     

       1618
       1618
       -
       		client,

     

       1619
       1619
       -
       		&tangled.RepoDelete_Input{

     

       1620
       1620
       -
       			Did:  f.OwnerDid(),

     

       1621
       1621
       -
       			Name: f.Name,

     

       1622
       1622
       -
       			Rkey: f.Rkey,

     

       1623
       1623
       -
       		},

     

       1624
       1624
       -
       	)

     

       1625
       1625
       -
       	if err := xrpcclient.HandleXrpcErr(err); err != nil {

     

       1626
       1626
       -
       		rp.pages.Notice(w, noticeId, err.Error())

     

       1627
       1627
       -
       		return

     

       1628
       1628
       -
       	}

     

       1629
       1629
       -
       	l.Info("deleted repo from knot")

     

       1630
       1630
       -
       

     

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

     

       1632
       1632
       -
       	if err != nil {

     

       1633
       1633
       -
       		l.Error("failed to start tx")

     

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

     

       1635
       1635
       -
       		return

     

       1636
       1636
       -
       	}

     

       1637
       1637
       -
       	defer func() {

     

       1638
       1638
       -
       		tx.Rollback()

     

       1639
       1639
       -
       		err = rp.enforcer.E.LoadPolicy()

     

       1640
       1640
       -
       		if err != nil {

     

       1641
       1641
       -
       			l.Error("failed to rollback policies")

     

       1642
       1642
       -
       		}

     

       1643
       1643
       -
       	}()

     

       1644
       1644
       -
       

     

       1645
       1645
       -
       	// remove collaborator RBAC

     

       1646
       1646
       -
       	repoCollaborators, err := rp.enforcer.E.GetImplicitUsersForResourceByDomain(f.DidSlashRepo(), f.Knot)

     

       1647
       1647
       -
       	if err != nil {

     

       1648
       1648
       -
       		rp.pages.Notice(w, noticeId, "Failed to remove collaborators")

     

       1649
       1649
       -
       		return

     

       1650
       1650
       -
       	}

     

       1651
       1651
       -
       	for _, c := range repoCollaborators {

     

       1652
       1652
       -
       		did := c[0]

     

       1653
       1653
       -
       		rp.enforcer.RemoveCollaborator(did, f.Knot, f.DidSlashRepo())

     

       1654
       1654
       -
       	}

     

       1655
       1655
       -
       	l.Info("removed collaborators")

     

       1656
       1656
       -
       

     

       1657
       1657
       -
       	// remove repo RBAC

     

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

     

       1659
       1659
       -
       	if err != nil {

     

       1660
       1660
       -
       		rp.pages.Notice(w, noticeId, "Failed to update RBAC rules")

     

       1661
       1661
       -
       		return

     

       1662
       1662
       -
       	}

     

       1663
       1663
       -
       

     

       1664
       1664
       -
       	// remove repo from db

     

       1665
       1665
       -
       	err = db.RemoveRepo(tx, f.OwnerDid(), f.Name)

     

       1666
       1666
       -
       	if err != nil {

     

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

     

       1668
       1668
       -
       		return

     

       1669
       1669
       -
       	}

     

       1670
       1670
       -
       	l.Info("removed repo from db")

     

       1671
       1671
       -
       

     

       1672
       1672
       -
       	err = tx.Commit()

     

       1673
       1673
       -
       	if err != nil {

     

       1674
       1674
       -
       		l.Error("failed to commit changes", "err", err)

     

       1675
       1675
       -
       		http.Error(w, err.Error(), http.StatusInternalServerError)

     

       1676
       1676
       -
       		return

     

       1677
       1677
       -
       	}

     

       1678
       1678
       -
       

     

       1679
       1679
       -
       	err = rp.enforcer.E.SavePolicy()

     

       1680
       1680
       -
       	if err != nil {

     

       1681
       1681
       -
       		l.Error("failed to update ACLs", "err", err)

     

       1682
       1682
       -
       		http.Error(w, err.Error(), http.StatusInternalServerError)

     

       1683
       1683
       -
       		return

     

       1684
       1684
       -
       	}

     

       1685
       1685
       -
       

     

       1686
       1686
       -
       	rp.pages.HxRedirect(w, fmt.Sprintf("/%s", f.OwnerDid()))

     

       1687
       1687
       -
       }

     

       1688
       1688
       -
       

     

       1689
       1689
       -
       func (rp *Repo) EditBaseSettings(w http.ResponseWriter, r *http.Request) {

     

       1690
       1690
       -
       	l := rp.logger.With("handler", "EditBaseSettings")

     

       1691
       1691
       -
       

     

       1692
       1692
       -
       	noticeId := "repo-base-settings-error"

     

       1693
       1693
       -
       

     

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

     

       1695
       1695
       -
       	if err != nil {

     

       1696
       1696
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       1697
       1697
       -
       		w.WriteHeader(http.StatusBadRequest)

     

       1698
       1698
       -
       		return

     

       1699
       1699
       -
       	}

     

       1700
       1700
       -
       

     

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

     

       1702
       1702
       -
       	if err != nil {

     

       1703
       1703
       -
       		l.Error("failed to get client")

     

       1704
       1704
       -
       		rp.pages.Notice(w, noticeId, "Failed to update repository information, try again later.")

     

       1705
       1705
       -
       		return

     

       1706
       1706
       -
       	}

     

       1707
       1707
       -
       

     

       1708
       1708
       -
       	var (

     

       1709
       1709
       -
       		description = r.FormValue("description")

     

       1710
       1710
       -
       		website     = r.FormValue("website")

     

       1711
       1711
       -
       		topicStr    = r.FormValue("topics")

     

       1712
       1712
       -
       	)

     

       1713
       1713
       -
       

     

       1714
       1714
       -
       	err = rp.validator.ValidateURI(website)

     

       1715
       1715
       -
       	if err != nil {

     

       1716
       1716
       -
       		l.Error("invalid uri", "err", err)

     

       1717
       1717
       -
       		rp.pages.Notice(w, noticeId, err.Error())

     

       1718
       1718
       -
       		return

     

       1719
       1719
       -
       	}

     

       1720
       1720
       -
       

     

       1721
       1721
       -
       	topics, err := rp.validator.ValidateRepoTopicStr(topicStr)

     

       1722
       1722
       -
       	if err != nil {

     

       1723
       1723
       -
       		l.Error("invalid topics", "err", err)

     

       1724
       1724
       -
       		rp.pages.Notice(w, noticeId, err.Error())

     

       1725
       1725
       -
       		return

     

       1726
       1726
       -
       	}

     

       1727
       1727
       -
       	l.Debug("got", "topicsStr", topicStr, "topics", topics)

     

       1728
       1728
       -
       

     

       1729
       1729
       -
       	newRepo := f.Repo

     

       1730
       1730
       -
       	newRepo.Description = description

     

       1731
       1731
       -
       	newRepo.Website = website

     

       1732
       1732
       -
       	newRepo.Topics = topics

     

       1733
       1733
       -
       	record := newRepo.AsRecord()

     

       1734
       1734
       -
       

     

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

     

       1736
       1736
       -
       	if err != nil {

     

       1737
       1737
       -
       		l.Error("failed to begin transaction", "err", err)

     

       1738
       1738
       -
       		rp.pages.Notice(w, noticeId, "Failed to save repository information.")

     

       1739
       1739
       -
       		return

     

       1740
       1740
       -
       	}

     

       1741
       1741
       -
       	defer tx.Rollback()

     

       1742
       1742
       -
       

     

       1743
       1743
       -
       	err = db.PutRepo(tx, newRepo)

     

       1744
       1744
       -
       	if err != nil {

     

       1745
       1745
       -
       		l.Error("failed to update repository", "err", err)

     

       1746
       1746
       -
       		rp.pages.Notice(w, noticeId, "Failed to save repository information.")

     

       1747
       1747
       -
       		return

     

       1748
       1748
       -
       	}

     

       1749
       1749
       -
       

     

       1750
       1750
       -
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, newRepo.Did, newRepo.Rkey)

     

       1751
       1751
       -
       	if err != nil {

     

       1752
       1752
       -
       		// failed to get record

     

       1753
       1753
       -
       		l.Error("failed to get repo record", "err", err)

     

       1754
       1754
       -
       		rp.pages.Notice(w, noticeId, "Failed to save repository information, no record found on PDS.")

     

       1755
       1755
       -
       		return

     

       1756
       1756
       -
       	}

     

       1757
       1757
       -
       	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{

     

       1758
       1758
       -
       		Collection: tangled.RepoNSID,

     

       1759
       1759
       -
       		Repo:       newRepo.Did,

     

       1760
       1760
       -
       		Rkey:       newRepo.Rkey,

     

       1761
       1761
       -
       		SwapRecord: ex.Cid,

     

       1762
       1762
       -
       		Record: &lexutil.LexiconTypeDecoder{

     

       1763
       1763
       -
       			Val: &record,

     

       1764
       1764
       -
       		},

     

       800
       800
       +
       		Created:    createdAt,

     

       1765
       801
        
       	})

     

       1766
       1766
       -
       

     

       1767
       802
        
       	if err != nil {

     

       1768
       1768
       -
       		l.Error("failed to perferom update-repo query", "err", err)

     

       1769
       1769
       -
       		// failed to get record

     

       1770
       1770
       -
       		rp.pages.Notice(w, noticeId, "Failed to save repository information, unable to save to PDS.")

     

       803
       803
       +
       		fail("Failed to add collaborator.", err)

     

       1771
       804
        
       		return

     

       1772
       805
        
       	}

     

       1773
       806
        
       

     

       1774
       807
        
       	err = tx.Commit()

     

       1775
       808
        
       	if err != nil {

     

       1776
       1776
       -
       		l.Error("failed to commit", "err", err)

     

       809
       809
       +
       		fail("Failed to add collaborator.", err)

     

       810
       810
       +
       		return

     

       811
       811
       +
       	}

     

       812
       812
       +
       

     

       813
       813
       +
       	err = rp.enforcer.E.SavePolicy()

     

       814
       814
       +
       	if err != nil {

     

       815
       815
       +
       		fail("Failed to update collaborator permissions.", err)

     

       816
       816
       +
       		return

     

       1777
       817
        
       	}

     

       1778
       818
        
       

     

       819
       819
       +
       	// clear aturi to when everything is successful

     

       820
       820
       +
       	aturi = ""

     

       821
       821
       +
       

     

       1779
       822
        
       	rp.pages.HxRefresh(w)

     

       1780
       823
        
       }

     

       1781
       824
        
       

     

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

     

       1783
       1783
       -
       	l := rp.logger.With("handler", "SetDefaultBranch")

     

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

     

       826
       826
       +
       	user := rp.oauth.GetUser(r)

     

       827
       827
       +
       	l := rp.logger.With("handler", "DeleteRepo")

     

       1784
       828
        
       

     

       829
       829
       +
       	noticeId := "operation-error"

     

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

     

       1786
       831
        
       	if err != nil {

     

       1787
       832
        
       		l.Error("failed to get repo and knot", "err", err)

     

       1788
       833
        
       		return

     

       1789
       834
        
       	}

     

       1790
       835
        
       

     

       1791
       1791
       -
       	noticeId := "operation-error"

     

       1792
       1792
       -
       	branch := r.FormValue("branch")

     

       1793
       1793
       -
       	if branch == "" {

     

       1794
       1794
       -
       		http.Error(w, "malformed form", http.StatusBadRequest)

     

       836
       836
       +
       	// remove record from pds

     

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

     

       838
       838
       +
       	if err != nil {

     

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

     

       840
       840
       +
       		return

     

       841
       841
       +
       	}

     

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

     

       843
       843
       +
       		Collection: tangled.RepoNSID,

     

       844
       844
       +
       		Repo:       user.Did,

     

       845
       845
       +
       		Rkey:       f.Rkey,

     

       846
       846
       +
       	})

     

       847
       847
       +
       	if err != nil {

     

       848
       848
       +
       		l.Error("failed to delete record", "err", err)

     

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

     

       1795
       850
        
       		return

     

       1796
       851
        
       	}

     

       852
       852
       +
       	l.Info("removed repo record", "aturi", f.RepoAt().String())

     

       1797
       853
        
       

     

       1798
       854
        
       	client, err := rp.oauth.ServiceClient(

     

       1799
       855
        
       		r,

     

       1800
       856
        
       		oauth.WithService(f.Knot),

     

       1801
       1801
       -
       		oauth.WithLxm(tangled.RepoSetDefaultBranchNSID),

     

       857
       857
       +
       		oauth.WithLxm(tangled.RepoDeleteNSID),

     

       1802
       858
        
       		oauth.WithDev(rp.config.Core.Dev),

     

       1803
       859
        
       	)

     

       1804
       860
        
       	if err != nil {

     

       1805
       861
        
       		l.Error("failed to connect to knot server", "err", err)

     

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

     

       1807
       862
        
       		return

     

       1808
       863
        
       	}

     

       1809
       864
        
       

     

       1810
       1810
       -
       	xe := tangled.RepoSetDefaultBranch(

     

       865
       865
       +
       	err = tangled.RepoDelete(

     

       1811
       866
        
       		r.Context(),

     

       1812
       867
        
       		client,

     

       1813
       1813
       -
       		&tangled.RepoSetDefaultBranch_Input{

     

       1814
       1814
       -
       			Repo:          f.RepoAt().String(),

     

       1815
       1815
       -
       			DefaultBranch: branch,

     

       868
       868
       +
       		&tangled.RepoDelete_Input{

     

       869
       869
       +
       			Did:  f.OwnerDid(),

     

       870
       870
       +
       			Name: f.Name,

     

       871
       871
       +
       			Rkey: f.Rkey,

     

       1816
       872
        
       		},

     

       1817
       873
        
       	)

     

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

     

       1819
       1819
       -
       		l.Error("xrpc failed", "err", xe)

     

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

     

       1820
       875
        
       		rp.pages.Notice(w, noticeId, err.Error())

     

       1821
       876
        
       		return

     

       1822
       877
        
       	}

     

       878
       878
       +
       	l.Info("deleted repo from knot")

     

       1823
       879
        
       

     

       1824
       1824
       -
       	rp.pages.HxRefresh(w)

     

       1825
       1825
       -
       }

     

       1826
       1826
       -
       

     

       1827
       1827
       -
       func (rp *Repo) Secrets(w http.ResponseWriter, r *http.Request) {

     

       1828
       1828
       -
       	user := rp.oauth.GetUser(r)

     

       1829
       1829
       -
       	l := rp.logger.With("handler", "Secrets")

     

       1830
       1830
       -
       	l = l.With("did", user.Did)

     

       1831
       1831
       -
       

     

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

     

       1833
       1833
       -
       	if err != nil {

     

       1834
       1834
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       1835
       1835
       -
       		return

     

       1836
       1836
       -
       	}

     

       1837
       1837
       -
       

     

       1838
       1838
       -
       	if f.Spindle == "" {

     

       1839
       1839
       -
       		l.Error("empty spindle cannot add/rm secret", "err", err)

     

       1840
       1840
       -
       		return

     

       1841
       1841
       -
       	}

     

       1842
       1842
       -
       

     

       1843
       1843
       -
       	lxm := tangled.RepoAddSecretNSID

     

       1844
       1844
       -
       	if r.Method == http.MethodDelete {

     

       1845
       1845
       -
       		lxm = tangled.RepoRemoveSecretNSID

     

       1846
       1846
       -
       	}

     

       1847
       1847
       -
       

     

       1848
       1848
       -
       	spindleClient, err := rp.oauth.ServiceClient(

     

       1849
       1849
       -
       		r,

     

       1850
       1850
       -
       		oauth.WithService(f.Spindle),

     

       1851
       1851
       -
       		oauth.WithLxm(lxm),

     

       1852
       1852
       -
       		oauth.WithExp(60),

     

       1853
       1853
       -
       		oauth.WithDev(rp.config.Core.Dev),

     

       1854
       1854
       -
       	)

     

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

     

       1855
       881
        
       	if err != nil {

     

       1856
       1856
       -
       		l.Error("failed to create spindle client", "err", err)

     

       1857
       1857
       -
       		return

     

       1858
       1858
       -
       	}

     

       1859
       1859
       -
       

     

       1860
       1860
       -
       	key := r.FormValue("key")

     

       1861
       1861
       -
       	if key == "" {

     

       1862
       1862
       -
       		w.WriteHeader(http.StatusBadRequest)

     

       882
       882
       +
       		l.Error("failed to start tx")

     

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

     

       1863
       884
        
       		return

     

       1864
       885
        
       	}

     

       1865
       1865
       -
       

     

       1866
       1866
       -
       	switch r.Method {

     

       1867
       1867
       -
       	case http.MethodPut:

     

       1868
       1868
       -
       		errorId := "add-secret-error"

     

       1869
       1869
       -
       

     

       1870
       1870
       -
       		value := r.FormValue("value")

     

       1871
       1871
       -
       		if value == "" {

     

       1872
       1872
       -
       			w.WriteHeader(http.StatusBadRequest)

     

       1873
       1873
       -
       			return

     

       1874
       1874
       -
       		}

     

       1875
       1875
       -
       

     

       1876
       1876
       -
       		err = tangled.RepoAddSecret(

     

       1877
       1877
       -
       			r.Context(),

     

       1878
       1878
       -
       			spindleClient,

     

       1879
       1879
       -
       			&tangled.RepoAddSecret_Input{

     

       1880
       1880
       -
       				Repo:  f.RepoAt().String(),

     

       1881
       1881
       -
       				Key:   key,

     

       1882
       1882
       -
       				Value: value,

     

       1883
       1883
       -
       			},

     

       1884
       1884
       -
       		)

     

       1885
       1885
       -
       		if err != nil {

     

       1886
       1886
       -
       			l.Error("Failed to add secret.", "err", err)

     

       1887
       1887
       -
       			rp.pages.Notice(w, errorId, "Failed to add secret.")

     

       1888
       1888
       -
       			return

     

       1889
       1889
       -
       		}

     

       1890
       1890
       -
       

     

       1891
       1891
       -
       	case http.MethodDelete:

     

       1892
       1892
       -
       		errorId := "operation-error"

     

       1893
       1893
       -
       

     

       1894
       1894
       -
       		err = tangled.RepoRemoveSecret(

     

       1895
       1895
       -
       			r.Context(),

     

       1896
       1896
       -
       			spindleClient,

     

       1897
       1897
       -
       			&tangled.RepoRemoveSecret_Input{

     

       1898
       1898
       -
       				Repo: f.RepoAt().String(),

     

       1899
       1899
       -
       				Key:  key,

     

       1900
       1900
       -
       			},

     

       1901
       1901
       -
       		)

     

       886
       886
       +
       	defer func() {

     

       887
       887
       +
       		tx.Rollback()

     

       888
       888
       +
       		err = rp.enforcer.E.LoadPolicy()

     

       1902
       889
        
       		if err != nil {

     

       1903
       1903
       -
       			l.Error("Failed to delete secret.", "err", err)

     

       1904
       1904
       -
       			rp.pages.Notice(w, errorId, "Failed to delete secret.")

     

       1905
       1905
       -
       			return

     

       890
       890
       +
       			l.Error("failed to rollback policies")

     

       1906
       891
        
       		}

     

       1907
       1907
       -
       	}

     

       1908
       1908
       -
       

     

       1909
       1909
       -
       	rp.pages.HxRefresh(w)

     

       1910
       1910
       -
       }

     

       1911
       1911
       -
       

     

       1912
       1912
       -
       type tab = map[string]any

     

       1913
       1913
       -
       

     

       1914
       1914
       -
       var (

     

       1915
       1915
       -
       	// would be great to have ordered maps right about now

     

       1916
       1916
       -
       	settingsTabs []tab = []tab{

     

       1917
       1917
       -
       		{"Name": "general", "Icon": "sliders-horizontal"},

     

       1918
       1918
       -
       		{"Name": "access", "Icon": "users"},

     

       1919
       1919
       -
       		{"Name": "pipelines", "Icon": "layers-2"},

     

       1920
       1920
       -
       	}

     

       1921
       1921
       -
       )

     

       1922
       1922
       -
       

     

       1923
       1923
       -
       func (rp *Repo) RepoSettings(w http.ResponseWriter, r *http.Request) {

     

       1924
       1924
       -
       	tabVal := r.URL.Query().Get("tab")

     

       1925
       1925
       -
       	if tabVal == "" {

     

       1926
       1926
       -
       		tabVal = "general"

     

       1927
       1927
       -
       	}

     

       1928
       1928
       -
       

     

       1929
       1929
       -
       	switch tabVal {

     

       1930
       1930
       -
       	case "general":

     

       1931
       1931
       -
       		rp.generalSettings(w, r)

     

       1932
       1932
       -
       

     

       1933
       1933
       -
       	case "access":

     

       1934
       1934
       -
       		rp.accessSettings(w, r)

     

       1935
       1935
       -
       

     

       1936
       1936
       -
       	case "pipelines":

     

       1937
       1937
       -
       		rp.pipelineSettings(w, r)

     

       1938
       1938
       -
       	}

     

       1939
       1939
       -
       }

     

       1940
       1940
       -
       

     

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

     

       1942
       1942
       -
       	l := rp.logger.With("handler", "generalSettings")

     

       1943
       1943
       -
       

     

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

     

       1945
       1945
       -
       	user := rp.oauth.GetUser(r)

     

       1946
       1946
       -
       

     

       1947
       1947
       -
       	scheme := "http"

     

       1948
       1948
       -
       	if !rp.config.Core.Dev {

     

       1949
       1949
       -
       		scheme = "https"

     

       1950
       1950
       -
       	}

     

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

     

       1952
       1952
       -
       	xrpcc := &indigoxrpc.Client{

     

       1953
       1953
       -
       		Host: host,

     

       1954
       1954
       -
       	}

     

       892
       892
       +
       	}()

     

       1955
       893
        
       

     

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

     

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

     

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

     

       1959
       1959
       -
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       1960
       1960
       -
       		rp.pages.Error503(w)

     

       894
       894
       +
       	// remove collaborator RBAC

     

       895
       895
       +
       	repoCollaborators, err := rp.enforcer.E.GetImplicitUsersForResourceByDomain(f.DidSlashRepo(), f.Knot)

     

       896
       896
       +
       	if err != nil {

     

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

     

       1961
       898
        
       		return

     

       1962
       899
        
       	}

     

       1963
       1963
       -
       

     

       1964
       1964
       -
       	var result types.RepoBranchesResponse

     

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

     

       1966
       1966
       -
       		l.Error("failed to decode XRPC response", "err", err)

     

       1967
       1967
       -
       		rp.pages.Error503(w)

     

       1968
       1968
       -
       		return

     

       900
       900
       +
       	for _, c := range repoCollaborators {

     

       901
       901
       +
       		did := c[0]

     

       902
       902
       +
       		rp.enforcer.RemoveCollaborator(did, f.Knot, f.DidSlashRepo())

     

       1969
       903
        
       	}

     

       904
       904
       +
       	l.Info("removed collaborators")

     

       1970
       905
        
       

     

       1971
       1971
       -
       	defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", rp.config.Label.DefaultLabelDefs))

     

       906
       906
       +
       	// remove repo RBAC

     

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

     

       1972
       908
        
       	if err != nil {

     

       1973
       1973
       -
       		l.Error("failed to fetch labels", "err", err)

     

       1974
       1974
       -
       		rp.pages.Error503(w)

     

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

     

       1975
       910
        
       		return

     

       1976
       911
        
       	}

     

       1977
       912
        
       

     

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

     

       913
       913
       +
       	// remove repo from db

     

       914
       914
       +
       	err = db.RemoveRepo(tx, f.OwnerDid(), f.Name)

     

       1979
       915
        
       	if err != nil {

     

       1980
       1980
       -
       		l.Error("failed to fetch labels", "err", err)

     

       1981
       1981
       -
       		rp.pages.Error503(w)

     

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

     

       1982
       917
        
       		return

     

       1983
       918
        
       	}

     

       1984
       1984
       -
       	// remove default labels from the labels list, if present

     

       1985
       1985
       -
       	defaultLabelMap := make(map[string]bool)

     

       1986
       1986
       -
       	for _, dl := range defaultLabels {

     

       1987
       1987
       -
       		defaultLabelMap[dl.AtUri().String()] = true

     

       1988
       1988
       -
       	}

     

       1989
       1989
       -
       	n := 0

     

       1990
       1990
       -
       	for _, l := range labels {

     

       1991
       1991
       -
       		if !defaultLabelMap[l.AtUri().String()] {

     

       1992
       1992
       -
       			labels[n] = l

     

       1993
       1993
       -
       			n++

     

       1994
       1994
       -
       		}

     

       1995
       1995
       -
       	}

     

       1996
       1996
       -
       	labels = labels[:n]

     

       1997
       1997
       -
       

     

       1998
       1998
       -
       	subscribedLabels := make(map[string]struct{})

     

       1999
       1999
       -
       	for _, l := range f.Repo.Labels {

     

       2000
       2000
       -
       		subscribedLabels[l] = struct{}{}

     

       2001
       2001
       -
       	}

     

       2002
       2002
       -
       

     

       2003
       2003
       -
       	// if there is atleast 1 unsubbed default label, show the "subscribe all" button,

     

       2004
       2004
       -
       	// if all default labels are subbed, show the "unsubscribe all" button

     

       2005
       2005
       -
       	shouldSubscribeAll := false

     

       2006
       2006
       -
       	for _, dl := range defaultLabels {

     

       2007
       2007
       -
       		if _, ok := subscribedLabels[dl.AtUri().String()]; !ok {

     

       2008
       2008
       -
       			// one of the default labels is not subscribed to

     

       2009
       2009
       -
       			shouldSubscribeAll = true

     

       2010
       2010
       -
       			break

     

       2011
       2011
       -
       		}

     

       2012
       2012
       -
       	}

     

       2013
       2013
       -
       

     

       2014
       2014
       -
       	rp.pages.RepoGeneralSettings(w, pages.RepoGeneralSettingsParams{

     

       2015
       2015
       -
       		LoggedInUser:       user,

     

       2016
       2016
       -
       		RepoInfo:           f.RepoInfo(user),

     

       2017
       2017
       -
       		Branches:           result.Branches,

     

       2018
       2018
       -
       		Labels:             labels,

     

       2019
       2019
       -
       		DefaultLabels:      defaultLabels,

     

       2020
       2020
       -
       		SubscribedLabels:   subscribedLabels,

     

       2021
       2021
       -
       		ShouldSubscribeAll: shouldSubscribeAll,

     

       2022
       2022
       -
       		Tabs:               settingsTabs,

     

       2023
       2023
       -
       		Tab:                "general",

     

       2024
       2024
       -
       	})

     

       2025
       2025
       -
       }

     

       2026
       2026
       -
       

     

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

     

       2028
       2028
       -
       	l := rp.logger.With("handler", "accessSettings")

     

       2029
       2029
       -
       

     

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

     

       2031
       2031
       -
       	user := rp.oauth.GetUser(r)

     

       919
       919
       +
       	l.Info("removed repo from db")

     

       2032
       920
        
       

     

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

     

       921
       921
       +
       	err = tx.Commit()

     

       2034
       922
        
       	if err != nil {

     

       2035
       2035
       -
       		l.Error("failed to get collaborators", "err", err)

     

       923
       923
       +
       		l.Error("failed to commit changes", "err", err)

     

       924
       924
       +
       		http.Error(w, err.Error(), http.StatusInternalServerError)

     

       925
       925
       +
       		return

     

       2036
       926
        
       	}

     

       2037
       927
        
       

     

       2038
       2038
       -
       	rp.pages.RepoAccessSettings(w, pages.RepoAccessSettingsParams{

     

       2039
       2039
       -
       		LoggedInUser:  user,

     

       2040
       2040
       -
       		RepoInfo:      f.RepoInfo(user),

     

       2041
       2041
       -
       		Tabs:          settingsTabs,

     

       2042
       2042
       -
       		Tab:           "access",

     

       2043
       2043
       -
       		Collaborators: repoCollaborators,

     

       2044
       2044
       -
       	})

     

       2045
       2045
       -
       }

     

       2046
       2046
       -
       

     

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

     

       2048
       2048
       -
       	l := rp.logger.With("handler", "pipelineSettings")

     

       2049
       2049
       -
       

     

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

     

       2051
       2051
       -
       	user := rp.oauth.GetUser(r)

     

       2052
       2052
       -
       

     

       2053
       2053
       -
       	// all spindles that the repo owner is a member of

     

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

     

       928
       928
       +
       	err = rp.enforcer.E.SavePolicy()

     

       2055
       929
        
       	if err != nil {

     

       2056
       2056
       -
       		l.Error("failed to fetch spindles", "err", err)

     

       930
       930
       +
       		l.Error("failed to update ACLs", "err", err)

     

       931
       931
       +
       		http.Error(w, err.Error(), http.StatusInternalServerError)

     

       2057
       932
        
       		return

     

       2058
       933
        
       	}

     

       2059
       934
        
       

     

       2060
       2060
       -
       	var secrets []*tangled.RepoListSecrets_Secret

     

       2061
       2061
       -
       	if f.Spindle != "" {

     

       2062
       2062
       -
       		if spindleClient, err := rp.oauth.ServiceClient(

     

       2063
       2063
       -
       			r,

     

       2064
       2064
       -
       			oauth.WithService(f.Spindle),

     

       2065
       2065
       -
       			oauth.WithLxm(tangled.RepoListSecretsNSID),

     

       2066
       2066
       -
       			oauth.WithExp(60),

     

       2067
       2067
       -
       			oauth.WithDev(rp.config.Core.Dev),

     

       2068
       2068
       -
       		); err != nil {

     

       2069
       2069
       -
       			l.Error("failed to create spindle client", "err", err)

     

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

     

       2071
       2071
       -
       			l.Error("failed to fetch secrets", "err", err)

     

       2072
       2072
       -
       		} else {

     

       2073
       2073
       -
       			secrets = resp.Secrets

     

       2074
       2074
       -
       		}

     

       2075
       2075
       -
       	}

     

       2076
       2076
       -
       

     

       2077
       2077
       -
       	slices.SortFunc(secrets, func(a, b *tangled.RepoListSecrets_Secret) int {

     

       2078
       2078
       -
       		return strings.Compare(a.Key, b.Key)

     

       2079
       2079
       -
       	})

     

       2080
       2080
       -
       

     

       2081
       2081
       -
       	var dids []string

     

       2082
       2082
       -
       	for _, s := range secrets {

     

       2083
       2083
       -
       		dids = append(dids, s.CreatedBy)

     

       2084
       2084
       -
       	}

     

       2085
       2085
       -
       	resolvedIdents := rp.idResolver.ResolveIdents(r.Context(), dids)

     

       2086
       2086
       -
       

     

       2087
       2087
       -
       	// convert to a more manageable form

     

       2088
       2088
       -
       	var niceSecret []map[string]any

     

       2089
       2089
       -
       	for id, s := range secrets {

     

       2090
       2090
       -
       		when, _ := time.Parse(time.RFC3339, s.CreatedAt)

     

       2091
       2091
       -
       		niceSecret = append(niceSecret, map[string]any{

     

       2092
       2092
       -
       			"Id":        id,

     

       2093
       2093
       -
       			"Key":       s.Key,

     

       2094
       2094
       -
       			"CreatedAt": when,

     

       2095
       2095
       -
       			"CreatedBy": resolvedIdents[id].Handle.String(),

     

       2096
       2096
       -
       		})

     

       2097
       2097
       -
       	}

     

       2098
       2098
       -
       

     

       2099
       2099
       -
       	rp.pages.RepoPipelineSettings(w, pages.RepoPipelineSettingsParams{

     

       2100
       2100
       -
       		LoggedInUser:   user,

     

       2101
       2101
       -
       		RepoInfo:       f.RepoInfo(user),

     

       2102
       2102
       -
       		Tabs:           settingsTabs,

     

       2103
       2103
       -
       		Tab:            "pipelines",

     

       2104
       2104
       -
       		Spindles:       spindles,

     

       2105
       2105
       -
       		CurrentSpindle: f.Spindle,

     

       2106
       2106
       -
       		Secrets:        niceSecret,

     

       2107
       2107
       -
       	})

     

       935
       935
       +
       	rp.pages.HxRedirect(w, fmt.Sprintf("/%s", f.OwnerDid()))

     

       2108
       936
        
       }

     

       2109
       937
        
       

     

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

     
···

       2388
       1216
        
       	})

     

       2389
       1217
        
       	return err

     

       2390
       1218
        
       }

     

       2391
       2391
       -
       

     

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

     

       2393
       2393
       -
       	l := rp.logger.With("handler", "RepoCompareNew")

     

       2394
       2394
       -
       

     

       2395
       2395
       -
       	user := rp.oauth.GetUser(r)

     

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

     

       2397
       2397
       -
       	if err != nil {

     

       2398
       2398
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       2399
       2399
       -
       		return

     

       2400
       2400
       -
       	}

     

       2401
       2401
       -
       

     

       2402
       2402
       -
       	scheme := "http"

     

       2403
       2403
       -
       	if !rp.config.Core.Dev {

     

       2404
       2404
       -
       		scheme = "https"

     

       2405
       2405
       -
       	}

     

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

     

       2407
       2407
       -
       	xrpcc := &indigoxrpc.Client{

     

       2408
       2408
       -
       		Host: host,

     

       2409
       2409
       -
       	}

     

       2410
       2410
       -
       

     

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

     

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

     

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

     

       2414
       2414
       -
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       2415
       2415
       -
       		rp.pages.Error503(w)

     

       2416
       2416
       -
       		return

     

       2417
       2417
       -
       	}

     

       2418
       2418
       -
       

     

       2419
       2419
       -
       	var branchResult types.RepoBranchesResponse

     

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

     

       2421
       2421
       -
       		l.Error("failed to decode XRPC branches response", "err", err)

     

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

     

       2423
       2423
       -
       		return

     

       2424
       2424
       -
       	}

     

       2425
       2425
       -
       	branches := branchResult.Branches

     

       2426
       2426
       -
       

     

       2427
       2427
       -
       	sortBranches(branches)

     

       2428
       2428
       -
       

     

       2429
       2429
       -
       	var defaultBranch string

     

       2430
       2430
       -
       	for _, b := range branches {

     

       2431
       2431
       -
       		if b.IsDefault {

     

       2432
       2432
       -
       			defaultBranch = b.Name

     

       2433
       2433
       -
       		}

     

       2434
       2434
       -
       	}

     

       2435
       2435
       -
       

     

       2436
       2436
       -
       	base := defaultBranch

     

       2437
       2437
       -
       	head := defaultBranch

     

       2438
       2438
       -
       

     

       2439
       2439
       -
       	params := r.URL.Query()

     

       2440
       2440
       -
       	queryBase := params.Get("base")

     

       2441
       2441
       -
       	queryHead := params.Get("head")

     

       2442
       2442
       -
       	if queryBase != "" {

     

       2443
       2443
       -
       		base = queryBase

     

       2444
       2444
       -
       	}

     

       2445
       2445
       -
       	if queryHead != "" {

     

       2446
       2446
       -
       		head = queryHead

     

       2447
       2447
       -
       	}

     

       2448
       2448
       -
       

     

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

     

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

     

       2451
       2451
       -
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       2452
       2452
       -
       		rp.pages.Error503(w)

     

       2453
       2453
       -
       		return

     

       2454
       2454
       -
       	}

     

       2455
       2455
       -
       

     

       2456
       2456
       -
       	var tags types.RepoTagsResponse

     

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

     

       2458
       2458
       -
       		l.Error("failed to decode XRPC tags response", "err", err)

     

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

     

       2460
       2460
       -
       		return

     

       2461
       2461
       -
       	}

     

       2462
       2462
       -
       

     

       2463
       2463
       -
       	repoinfo := f.RepoInfo(user)

     

       2464
       2464
       -
       

     

       2465
       2465
       -
       	rp.pages.RepoCompareNew(w, pages.RepoCompareNewParams{

     

       2466
       2466
       -
       		LoggedInUser: user,

     

       2467
       2467
       -
       		RepoInfo:     repoinfo,

     

       2468
       2468
       -
       		Branches:     branches,

     

       2469
       2469
       -
       		Tags:         tags.Tags,

     

       2470
       2470
       -
       		Base:         base,

     

       2471
       2471
       -
       		Head:         head,

     

       2472
       2472
       -
       	})

     

       2473
       2473
       -
       }

     

       2474
       2474
       -
       

     

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

     

       2476
       2476
       -
       	l := rp.logger.With("handler", "RepoCompare")

     

       2477
       2477
       -
       

     

       2478
       2478
       -
       	user := rp.oauth.GetUser(r)

     

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

     

       2480
       2480
       -
       	if err != nil {

     

       2481
       2481
       -
       		l.Error("failed to get repo and knot", "err", err)

     

       2482
       2482
       -
       		return

     

       2483
       2483
       -
       	}

     

       2484
       2484
       -
       

     

       2485
       2485
       -
       	var diffOpts types.DiffOpts

     

       2486
       2486
       -
       	if d := r.URL.Query().Get("diff"); d == "split" {

     

       2487
       2487
       -
       		diffOpts.Split = true

     

       2488
       2488
       -
       	}

     

       2489
       2489
       -
       

     

       2490
       2490
       -
       	// if user is navigating to one of

     

       2491
       2491
       -
       	//   /compare/{base}/{head}

     

       2492
       2492
       -
       	//   /compare/{base}...{head}

     

       2493
       2493
       -
       	base := chi.URLParam(r, "base")

     

       2494
       2494
       -
       	head := chi.URLParam(r, "head")

     

       2495
       2495
       -
       	if base == "" && head == "" {

     

       2496
       2496
       -
       		rest := chi.URLParam(r, "*") // master...feature/xyz

     

       2497
       2497
       -
       		parts := strings.SplitN(rest, "...", 2)

     

       2498
       2498
       -
       		if len(parts) == 2 {

     

       2499
       2499
       -
       			base = parts[0]

     

       2500
       2500
       -
       			head = parts[1]

     

       2501
       2501
       -
       		}

     

       2502
       2502
       -
       	}

     

       2503
       2503
       -
       

     

       2504
       2504
       -
       	base, _ = url.PathUnescape(base)

     

       2505
       2505
       -
       	head, _ = url.PathUnescape(head)

     

       2506
       2506
       -
       

     

       2507
       2507
       -
       	if base == "" || head == "" {

     

       2508
       2508
       -
       		l.Error("invalid comparison")

     

       2509
       2509
       -
       		rp.pages.Error404(w)

     

       2510
       2510
       -
       		return

     

       2511
       2511
       -
       	}

     

       2512
       2512
       -
       

     

       2513
       2513
       -
       	scheme := "http"

     

       2514
       2514
       -
       	if !rp.config.Core.Dev {

     

       2515
       2515
       -
       		scheme = "https"

     

       2516
       2516
       -
       	}

     

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

     

       2518
       2518
       -
       	xrpcc := &indigoxrpc.Client{

     

       2519
       2519
       -
       		Host: host,

     

       2520
       2520
       -
       	}

     

       2521
       2521
       -
       

     

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

     

       2523
       2523
       -
       

     

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

     

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

     

       2526
       2526
       -
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       2527
       2527
       -
       		rp.pages.Error503(w)

     

       2528
       2528
       -
       		return

     

       2529
       2529
       -
       	}

     

       2530
       2530
       -
       

     

       2531
       2531
       -
       	var branches types.RepoBranchesResponse

     

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

     

       2533
       2533
       -
       		l.Error("failed to decode XRPC branches response", "err", err)

     

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

     

       2535
       2535
       -
       		return

     

       2536
       2536
       -
       	}

     

       2537
       2537
       -
       

     

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

     

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

     

       2540
       2540
       -
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       2541
       2541
       -
       		rp.pages.Error503(w)

     

       2542
       2542
       -
       		return

     

       2543
       2543
       -
       	}

     

       2544
       2544
       -
       

     

       2545
       2545
       -
       	var tags types.RepoTagsResponse

     

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

     

       2547
       2547
       -
       		l.Error("failed to decode XRPC tags response", "err", err)

     

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

     

       2549
       2549
       -
       		return

     

       2550
       2550
       -
       	}

     

       2551
       2551
       -
       

     

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

     

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

     

       2554
       2554
       -
       		l.Error("failed to call XRPC repo.compare", "err", xrpcerr)

     

       2555
       2555
       -
       		rp.pages.Error503(w)

     

       2556
       2556
       -
       		return

     

       2557
       2557
       -
       	}

     

       2558
       2558
       -
       

     

       2559
       2559
       -
       	var formatPatch types.RepoFormatPatchResponse

     

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

     

       2561
       2561
       -
       		l.Error("failed to decode XRPC compare response", "err", err)

     

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

     

       2563
       2563
       -
       		return

     

       2564
       2564
       -
       	}

     

       2565
       2565
       -
       

     

       2566
       2566
       -
       	var diff types.NiceDiff

     

       2567
       2567
       -
       	if formatPatch.CombinedPatchRaw != "" {

     

       2568
       2568
       -
       		diff = patchutil.AsNiceDiff(formatPatch.CombinedPatchRaw, base)

     

       2569
       2569
       -
       	} else {

     

       2570
       2570
       -
       		diff = patchutil.AsNiceDiff(formatPatch.FormatPatchRaw, base)

     

       2571
       2571
       -
       	}

     

       2572
       2572
       -
       

     

       2573
       2573
       -
       	repoinfo := f.RepoInfo(user)

     

       2574
       2574
       -
       

     

       2575
       2575
       -
       	rp.pages.RepoCompare(w, pages.RepoCompareParams{

     

       2576
       2576
       -
       		LoggedInUser: user,

     

       2577
       2577
       -
       		RepoInfo:     repoinfo,

     

       2578
       2578
       -
       		Branches:     branches.Branches,

     

       2579
       2579
       -
       		Tags:         tags.Tags,

     

       2580
       2580
       -
       		Base:         base,

     

       2581
       2581
       -
       		Head:         head,

     

       2582
       2582
       -
       		Diff:         &diff,

     

       2583
       2583
       -
       		DiffOpts:     diffOpts,

     

       2584
       2584
       -
       	})

     

       2585
       2585
       -
       

     

       2586
       2586
       -
       }

+14 -14

appview/repo/router.go

···

       9
       9
        
       

     

       10
       10
        
       func (rp *Repo) Router(mw *middleware.Middleware) http.Handler {

     

       11
       11
        
       	r := chi.NewRouter()

     

       12
       12
       -
       	r.Get("/", rp.RepoIndex)

     

       13
       13
       -
       	r.Get("/opengraph", rp.RepoOpenGraphSummary)

     

       14
       14
       -
       	r.Get("/feed.atom", rp.RepoAtomFeed)

     

       15
       15
       -
       	r.Get("/commits/{ref}", rp.RepoLog)

     

       12
       12
       +
       	r.Get("/", rp.Index)

     

       13
       13
       +
       	r.Get("/opengraph", rp.Opengraph)

     

       14
       14
       +
       	r.Get("/feed.atom", rp.AtomFeed)

     

       15
       15
       +
       	r.Get("/commits/{ref}", rp.Log)

     

       16
       16
        
       	r.Route("/tree/{ref}", func(r chi.Router) {

     

       17
       17
       -
       		r.Get("/", rp.RepoIndex)

     

       18
       18
       -
       		r.Get("/*", rp.RepoTree)

     

       17
       17
       +
       		r.Get("/", rp.Index)

     

       18
       18
       +
       		r.Get("/*", rp.Tree)

     

       19
       19
        
       	})

     

       20
       20
       -
       	r.Get("/commit/{ref}", rp.RepoCommit)

     

       21
       21
       -
       	r.Get("/branches", rp.RepoBranches)

     

       20
       20
       +
       	r.Get("/commit/{ref}", rp.Commit)

     

       21
       21
       +
       	r.Get("/branches", rp.Branches)

     

       22
       22
        
       	r.Delete("/branches", rp.DeleteBranch)

     

       23
       23
        
       	r.Route("/tags", func(r chi.Router) {

     

       24
       24
       -
       		r.Get("/", rp.RepoTags)

     

       24
       24
       +
       		r.Get("/", rp.Tags)

     

       25
       25
        
       		r.Route("/{tag}", func(r chi.Router) {

     

       26
       26
        
       			r.Get("/download/{file}", rp.DownloadArtifact)

     

       27
       27
        
       

     
···

       37
       37
        
       			})

     

       38
       38
        
       		})

     

       39
       39
        
       	})

     

       40
       40
       -
       	r.Get("/blob/{ref}/*", rp.RepoBlob)

     

       40
       40
       +
       	r.Get("/blob/{ref}/*", rp.Blob)

     

       41
       41
        
       	r.Get("/raw/{ref}/*", rp.RepoBlobRaw)

     

       42
       42
        
       

     

       43
       43
        
       	// intentionally doesn't use /* as this isn't

     
···

       54
       54
        
       	})

     

       55
       55
        
       

     

       56
       56
        
       	r.Route("/compare", func(r chi.Router) {

     

       57
       57
       -
       		r.Get("/", rp.RepoCompareNew) // start an new comparison

     

       57
       57
       +
       		r.Get("/", rp.CompareNew) // start an new comparison

     

       58
       58
        
       

     

       59
       59
        
       		// we have to wildcard here since we want to support GitHub's compare syntax

     

       60
       60
        
       		//   /compare/{ref1}...{ref2}

     

       61
       61
        
       		// for example:

     

       62
       62
        
       		//   /compare/master...some/feature

     

       63
       63
        
       		//   /compare/master...example.com:another/feature <- this is a fork

     

       64
       64
       -
       		r.Get("/{base}/{head}", rp.RepoCompare)

     

       65
       65
       -
       		r.Get("/*", rp.RepoCompare)

     

       64
       64
       +
       		r.Get("/{base}/{head}", rp.Compare)

     

       65
       65
       +
       		r.Get("/*", rp.Compare)

     

       66
       66
        
       	})

     

       67
       67
        
       

     

       68
       68
        
       	// label panel in issues/pulls/discussions/tasks

     
···

       75
       75
        
       	r.Group(func(r chi.Router) {

     

       76
       76
        
       		r.Use(middleware.AuthMiddleware(rp.oauth))

     

       77
       77
        
       		r.With(mw.RepoPermissionMiddleware("repo:settings")).Route("/settings", func(r chi.Router) {

     

       78
       78
       -
       			r.Get("/", rp.RepoSettings)

     

       78
       78
       +
       			r.Get("/", rp.Settings)

     

       79
       79
        
       			r.With(mw.RepoPermissionMiddleware("repo:owner")).Put("/base", rp.EditBaseSettings)

     

       80
       80
        
       			r.With(mw.RepoPermissionMiddleware("repo:owner")).Post("/spindle", rp.EditSpindle)

     

       81
       81
        
       			r.With(mw.RepoPermissionMiddleware("repo:owner")).Put("/label", rp.AddLabelDef)

+442

appview/repo/settings.go

···

       1
       1
       +
       package repo

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"net/http"

     

       7
       7
       +
       	"slices"

     

       8
       8
       +
       	"strings"

     

       9
       9
       +
       	"time"

     

       10
       10
       +
       

     

       11
       11
       +
       	"tangled.org/core/api/tangled"

     

       12
       12
       +
       	"tangled.org/core/appview/db"

     

       13
       13
       +
       	"tangled.org/core/appview/oauth"

     

       14
       14
       +
       	"tangled.org/core/appview/pages"

     

       15
       15
       +
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       16
       16
       +
       	"tangled.org/core/types"

     

       17
       17
       +
       

     

       18
       18
       +
       	comatproto "github.com/bluesky-social/indigo/api/atproto"

     

       19
       19
       +
       	lexutil "github.com/bluesky-social/indigo/lex/util"

     

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

     

       21
       21
       +
       )

     

       22
       22
       +
       

     

       23
       23
       +
       type tab = map[string]any

     

       24
       24
       +
       

     

       25
       25
       +
       var (

     

       26
       26
       +
       	// would be great to have ordered maps right about now

     

       27
       27
       +
       	settingsTabs []tab = []tab{

     

       28
       28
       +
       		{"Name": "general", "Icon": "sliders-horizontal"},

     

       29
       29
       +
       		{"Name": "access", "Icon": "users"},

     

       30
       30
       +
       		{"Name": "pipelines", "Icon": "layers-2"},

     

       31
       31
       +
       	}

     

       32
       32
       +
       )

     

       33
       33
       +
       

     

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

     

       35
       35
       +
       	l := rp.logger.With("handler", "SetDefaultBranch")

     

       36
       36
       +
       

     

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

     

       38
       38
       +
       	if err != nil {

     

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

     

       40
       40
       +
       		return

     

       41
       41
       +
       	}

     

       42
       42
       +
       

     

       43
       43
       +
       	noticeId := "operation-error"

     

       44
       44
       +
       	branch := r.FormValue("branch")

     

       45
       45
       +
       	if branch == "" {

     

       46
       46
       +
       		http.Error(w, "malformed form", http.StatusBadRequest)

     

       47
       47
       +
       		return

     

       48
       48
       +
       	}

     

       49
       49
       +
       

     

       50
       50
       +
       	client, err := rp.oauth.ServiceClient(

     

       51
       51
       +
       		r,

     

       52
       52
       +
       		oauth.WithService(f.Knot),

     

       53
       53
       +
       		oauth.WithLxm(tangled.RepoSetDefaultBranchNSID),

     

       54
       54
       +
       		oauth.WithDev(rp.config.Core.Dev),

     

       55
       55
       +
       	)

     

       56
       56
       +
       	if err != nil {

     

       57
       57
       +
       		l.Error("failed to connect to knot server", "err", err)

     

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

     

       59
       59
       +
       		return

     

       60
       60
       +
       	}

     

       61
       61
       +
       

     

       62
       62
       +
       	xe := tangled.RepoSetDefaultBranch(

     

       63
       63
       +
       		r.Context(),

     

       64
       64
       +
       		client,

     

       65
       65
       +
       		&tangled.RepoSetDefaultBranch_Input{

     

       66
       66
       +
       			Repo:          f.RepoAt().String(),

     

       67
       67
       +
       			DefaultBranch: branch,

     

       68
       68
       +
       		},

     

       69
       69
       +
       	)

     

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

     

       71
       71
       +
       		l.Error("xrpc failed", "err", xe)

     

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

     

       73
       73
       +
       		return

     

       74
       74
       +
       	}

     

       75
       75
       +
       

     

       76
       76
       +
       	rp.pages.HxRefresh(w)

     

       77
       77
       +
       }

     

       78
       78
       +
       

     

       79
       79
       +
       func (rp *Repo) Secrets(w http.ResponseWriter, r *http.Request) {

     

       80
       80
       +
       	user := rp.oauth.GetUser(r)

     

       81
       81
       +
       	l := rp.logger.With("handler", "Secrets")

     

       82
       82
       +
       	l = l.With("did", user.Did)

     

       83
       83
       +
       

     

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

     

       85
       85
       +
       	if err != nil {

     

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

     

       87
       87
       +
       		return

     

       88
       88
       +
       	}

     

       89
       89
       +
       

     

       90
       90
       +
       	if f.Spindle == "" {

     

       91
       91
       +
       		l.Error("empty spindle cannot add/rm secret", "err", err)

     

       92
       92
       +
       		return

     

       93
       93
       +
       	}

     

       94
       94
       +
       

     

       95
       95
       +
       	lxm := tangled.RepoAddSecretNSID

     

       96
       96
       +
       	if r.Method == http.MethodDelete {

     

       97
       97
       +
       		lxm = tangled.RepoRemoveSecretNSID

     

       98
       98
       +
       	}

     

       99
       99
       +
       

     

       100
       100
       +
       	spindleClient, err := rp.oauth.ServiceClient(

     

       101
       101
       +
       		r,

     

       102
       102
       +
       		oauth.WithService(f.Spindle),

     

       103
       103
       +
       		oauth.WithLxm(lxm),

     

       104
       104
       +
       		oauth.WithExp(60),

     

       105
       105
       +
       		oauth.WithDev(rp.config.Core.Dev),

     

       106
       106
       +
       	)

     

       107
       107
       +
       	if err != nil {

     

       108
       108
       +
       		l.Error("failed to create spindle client", "err", err)

     

       109
       109
       +
       		return

     

       110
       110
       +
       	}

     

       111
       111
       +
       

     

       112
       112
       +
       	key := r.FormValue("key")

     

       113
       113
       +
       	if key == "" {

     

       114
       114
       +
       		w.WriteHeader(http.StatusBadRequest)

     

       115
       115
       +
       		return

     

       116
       116
       +
       	}

     

       117
       117
       +
       

     

       118
       118
       +
       	switch r.Method {

     

       119
       119
       +
       	case http.MethodPut:

     

       120
       120
       +
       		errorId := "add-secret-error"

     

       121
       121
       +
       

     

       122
       122
       +
       		value := r.FormValue("value")

     

       123
       123
       +
       		if value == "" {

     

       124
       124
       +
       			w.WriteHeader(http.StatusBadRequest)

     

       125
       125
       +
       			return

     

       126
       126
       +
       		}

     

       127
       127
       +
       

     

       128
       128
       +
       		err = tangled.RepoAddSecret(

     

       129
       129
       +
       			r.Context(),

     

       130
       130
       +
       			spindleClient,

     

       131
       131
       +
       			&tangled.RepoAddSecret_Input{

     

       132
       132
       +
       				Repo:  f.RepoAt().String(),

     

       133
       133
       +
       				Key:   key,

     

       134
       134
       +
       				Value: value,

     

       135
       135
       +
       			},

     

       136
       136
       +
       		)

     

       137
       137
       +
       		if err != nil {

     

       138
       138
       +
       			l.Error("Failed to add secret.", "err", err)

     

       139
       139
       +
       			rp.pages.Notice(w, errorId, "Failed to add secret.")

     

       140
       140
       +
       			return

     

       141
       141
       +
       		}

     

       142
       142
       +
       

     

       143
       143
       +
       	case http.MethodDelete:

     

       144
       144
       +
       		errorId := "operation-error"

     

       145
       145
       +
       

     

       146
       146
       +
       		err = tangled.RepoRemoveSecret(

     

       147
       147
       +
       			r.Context(),

     

       148
       148
       +
       			spindleClient,

     

       149
       149
       +
       			&tangled.RepoRemoveSecret_Input{

     

       150
       150
       +
       				Repo: f.RepoAt().String(),

     

       151
       151
       +
       				Key:  key,

     

       152
       152
       +
       			},

     

       153
       153
       +
       		)

     

       154
       154
       +
       		if err != nil {

     

       155
       155
       +
       			l.Error("Failed to delete secret.", "err", err)

     

       156
       156
       +
       			rp.pages.Notice(w, errorId, "Failed to delete secret.")

     

       157
       157
       +
       			return

     

       158
       158
       +
       		}

     

       159
       159
       +
       	}

     

       160
       160
       +
       

     

       161
       161
       +
       	rp.pages.HxRefresh(w)

     

       162
       162
       +
       }

     

       163
       163
       +
       

     

       164
       164
       +
       func (rp *Repo) Settings(w http.ResponseWriter, r *http.Request) {

     

       165
       165
       +
       	tabVal := r.URL.Query().Get("tab")

     

       166
       166
       +
       	if tabVal == "" {

     

       167
       167
       +
       		tabVal = "general"

     

       168
       168
       +
       	}

     

       169
       169
       +
       

     

       170
       170
       +
       	switch tabVal {

     

       171
       171
       +
       	case "general":

     

       172
       172
       +
       		rp.generalSettings(w, r)

     

       173
       173
       +
       

     

       174
       174
       +
       	case "access":

     

       175
       175
       +
       		rp.accessSettings(w, r)

     

       176
       176
       +
       

     

       177
       177
       +
       	case "pipelines":

     

       178
       178
       +
       		rp.pipelineSettings(w, r)

     

       179
       179
       +
       	}

     

       180
       180
       +
       }

     

       181
       181
       +
       

     

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

     

       183
       183
       +
       	l := rp.logger.With("handler", "generalSettings")

     

       184
       184
       +
       

     

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

     

       186
       186
       +
       	user := rp.oauth.GetUser(r)

     

       187
       187
       +
       

     

       188
       188
       +
       	scheme := "http"

     

       189
       189
       +
       	if !rp.config.Core.Dev {

     

       190
       190
       +
       		scheme = "https"

     

       191
       191
       +
       	}

     

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

     

       193
       193
       +
       	xrpcc := &indigoxrpc.Client{

     

       194
       194
       +
       		Host: host,

     

       195
       195
       +
       	}

     

       196
       196
       +
       

     

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

     

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

     

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

     

       200
       200
       +
       		l.Error("failed to call XRPC repo.branches", "err", xrpcerr)

     

       201
       201
       +
       		rp.pages.Error503(w)

     

       202
       202
       +
       		return

     

       203
       203
       +
       	}

     

       204
       204
       +
       

     

       205
       205
       +
       	var result types.RepoBranchesResponse

     

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

     

       207
       207
       +
       		l.Error("failed to decode XRPC response", "err", err)

     

       208
       208
       +
       		rp.pages.Error503(w)

     

       209
       209
       +
       		return

     

       210
       210
       +
       	}

     

       211
       211
       +
       

     

       212
       212
       +
       	defaultLabels, err := db.GetLabelDefinitions(rp.db, db.FilterIn("at_uri", rp.config.Label.DefaultLabelDefs))

     

       213
       213
       +
       	if err != nil {

     

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

     

       215
       215
       +
       		rp.pages.Error503(w)

     

       216
       216
       +
       		return

     

       217
       217
       +
       	}

     

       218
       218
       +
       

     

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

     

       220
       220
       +
       	if err != nil {

     

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

     

       222
       222
       +
       		rp.pages.Error503(w)

     

       223
       223
       +
       		return

     

       224
       224
       +
       	}

     

       225
       225
       +
       	// remove default labels from the labels list, if present

     

       226
       226
       +
       	defaultLabelMap := make(map[string]bool)

     

       227
       227
       +
       	for _, dl := range defaultLabels {

     

       228
       228
       +
       		defaultLabelMap[dl.AtUri().String()] = true

     

       229
       229
       +
       	}

     

       230
       230
       +
       	n := 0

     

       231
       231
       +
       	for _, l := range labels {

     

       232
       232
       +
       		if !defaultLabelMap[l.AtUri().String()] {

     

       233
       233
       +
       			labels[n] = l

     

       234
       234
       +
       			n++

     

       235
       235
       +
       		}

     

       236
       236
       +
       	}

     

       237
       237
       +
       	labels = labels[:n]

     

       238
       238
       +
       

     

       239
       239
       +
       	subscribedLabels := make(map[string]struct{})

     

       240
       240
       +
       	for _, l := range f.Repo.Labels {

     

       241
       241
       +
       		subscribedLabels[l] = struct{}{}

     

       242
       242
       +
       	}

     

       243
       243
       +
       

     

       244
       244
       +
       	// if there is atleast 1 unsubbed default label, show the "subscribe all" button,

     

       245
       245
       +
       	// if all default labels are subbed, show the "unsubscribe all" button

     

       246
       246
       +
       	shouldSubscribeAll := false

     

       247
       247
       +
       	for _, dl := range defaultLabels {

     

       248
       248
       +
       		if _, ok := subscribedLabels[dl.AtUri().String()]; !ok {

     

       249
       249
       +
       			// one of the default labels is not subscribed to

     

       250
       250
       +
       			shouldSubscribeAll = true

     

       251
       251
       +
       			break

     

       252
       252
       +
       		}

     

       253
       253
       +
       	}

     

       254
       254
       +
       

     

       255
       255
       +
       	rp.pages.RepoGeneralSettings(w, pages.RepoGeneralSettingsParams{

     

       256
       256
       +
       		LoggedInUser:       user,

     

       257
       257
       +
       		RepoInfo:           f.RepoInfo(user),

     

       258
       258
       +
       		Branches:           result.Branches,

     

       259
       259
       +
       		Labels:             labels,

     

       260
       260
       +
       		DefaultLabels:      defaultLabels,

     

       261
       261
       +
       		SubscribedLabels:   subscribedLabels,

     

       262
       262
       +
       		ShouldSubscribeAll: shouldSubscribeAll,

     

       263
       263
       +
       		Tabs:               settingsTabs,

     

       264
       264
       +
       		Tab:                "general",

     

       265
       265
       +
       	})

     

       266
       266
       +
       }

     

       267
       267
       +
       

     

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

     

       269
       269
       +
       	l := rp.logger.With("handler", "accessSettings")

     

       270
       270
       +
       

     

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

     

       272
       272
       +
       	user := rp.oauth.GetUser(r)

     

       273
       273
       +
       

     

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

     

       275
       275
       +
       	if err != nil {

     

       276
       276
       +
       		l.Error("failed to get collaborators", "err", err)

     

       277
       277
       +
       	}

     

       278
       278
       +
       

     

       279
       279
       +
       	rp.pages.RepoAccessSettings(w, pages.RepoAccessSettingsParams{

     

       280
       280
       +
       		LoggedInUser:  user,

     

       281
       281
       +
       		RepoInfo:      f.RepoInfo(user),

     

       282
       282
       +
       		Tabs:          settingsTabs,

     

       283
       283
       +
       		Tab:           "access",

     

       284
       284
       +
       		Collaborators: repoCollaborators,

     

       285
       285
       +
       	})

     

       286
       286
       +
       }

     

       287
       287
       +
       

     

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

     

       289
       289
       +
       	l := rp.logger.With("handler", "pipelineSettings")

     

       290
       290
       +
       

     

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

     

       292
       292
       +
       	user := rp.oauth.GetUser(r)

     

       293
       293
       +
       

     

       294
       294
       +
       	// all spindles that the repo owner is a member of

     

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

     

       296
       296
       +
       	if err != nil {

     

       297
       297
       +
       		l.Error("failed to fetch spindles", "err", err)

     

       298
       298
       +
       		return

     

       299
       299
       +
       	}

     

       300
       300
       +
       

     

       301
       301
       +
       	var secrets []*tangled.RepoListSecrets_Secret

     

       302
       302
       +
       	if f.Spindle != "" {

     

       303
       303
       +
       		if spindleClient, err := rp.oauth.ServiceClient(

     

       304
       304
       +
       			r,

     

       305
       305
       +
       			oauth.WithService(f.Spindle),

     

       306
       306
       +
       			oauth.WithLxm(tangled.RepoListSecretsNSID),

     

       307
       307
       +
       			oauth.WithExp(60),

     

       308
       308
       +
       			oauth.WithDev(rp.config.Core.Dev),

     

       309
       309
       +
       		); err != nil {

     

       310
       310
       +
       			l.Error("failed to create spindle client", "err", err)

     

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

     

       312
       312
       +
       			l.Error("failed to fetch secrets", "err", err)

     

       313
       313
       +
       		} else {

     

       314
       314
       +
       			secrets = resp.Secrets

     

       315
       315
       +
       		}

     

       316
       316
       +
       	}

     

       317
       317
       +
       

     

       318
       318
       +
       	slices.SortFunc(secrets, func(a, b *tangled.RepoListSecrets_Secret) int {

     

       319
       319
       +
       		return strings.Compare(a.Key, b.Key)

     

       320
       320
       +
       	})

     

       321
       321
       +
       

     

       322
       322
       +
       	var dids []string

     

       323
       323
       +
       	for _, s := range secrets {

     

       324
       324
       +
       		dids = append(dids, s.CreatedBy)

     

       325
       325
       +
       	}

     

       326
       326
       +
       	resolvedIdents := rp.idResolver.ResolveIdents(r.Context(), dids)

     

       327
       327
       +
       

     

       328
       328
       +
       	// convert to a more manageable form

     

       329
       329
       +
       	var niceSecret []map[string]any

     

       330
       330
       +
       	for id, s := range secrets {

     

       331
       331
       +
       		when, _ := time.Parse(time.RFC3339, s.CreatedAt)

     

       332
       332
       +
       		niceSecret = append(niceSecret, map[string]any{

     

       333
       333
       +
       			"Id":        id,

     

       334
       334
       +
       			"Key":       s.Key,

     

       335
       335
       +
       			"CreatedAt": when,

     

       336
       336
       +
       			"CreatedBy": resolvedIdents[id].Handle.String(),

     

       337
       337
       +
       		})

     

       338
       338
       +
       	}

     

       339
       339
       +
       

     

       340
       340
       +
       	rp.pages.RepoPipelineSettings(w, pages.RepoPipelineSettingsParams{

     

       341
       341
       +
       		LoggedInUser:   user,

     

       342
       342
       +
       		RepoInfo:       f.RepoInfo(user),

     

       343
       343
       +
       		Tabs:           settingsTabs,

     

       344
       344
       +
       		Tab:            "pipelines",

     

       345
       345
       +
       		Spindles:       spindles,

     

       346
       346
       +
       		CurrentSpindle: f.Spindle,

     

       347
       347
       +
       		Secrets:        niceSecret,

     

       348
       348
       +
       	})

     

       349
       349
       +
       }

     

       350
       350
       +
       

     

       351
       351
       +
       func (rp *Repo) EditBaseSettings(w http.ResponseWriter, r *http.Request) {

     

       352
       352
       +
       	l := rp.logger.With("handler", "EditBaseSettings")

     

       353
       353
       +
       

     

       354
       354
       +
       	noticeId := "repo-base-settings-error"

     

       355
       355
       +
       

     

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

     

       357
       357
       +
       	if err != nil {

     

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

     

       359
       359
       +
       		w.WriteHeader(http.StatusBadRequest)

     

       360
       360
       +
       		return

     

       361
       361
       +
       	}

     

       362
       362
       +
       

     

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

     

       364
       364
       +
       	if err != nil {

     

       365
       365
       +
       		l.Error("failed to get client")

     

       366
       366
       +
       		rp.pages.Notice(w, noticeId, "Failed to update repository information, try again later.")

     

       367
       367
       +
       		return

     

       368
       368
       +
       	}

     

       369
       369
       +
       

     

       370
       370
       +
       	var (

     

       371
       371
       +
       		description = r.FormValue("description")

     

       372
       372
       +
       		website     = r.FormValue("website")

     

       373
       373
       +
       		topicStr    = r.FormValue("topics")

     

       374
       374
       +
       	)

     

       375
       375
       +
       

     

       376
       376
       +
       	err = rp.validator.ValidateURI(website)

     

       377
       377
       +
       	if err != nil {

     

       378
       378
       +
       		l.Error("invalid uri", "err", err)

     

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

     

       380
       380
       +
       		return

     

       381
       381
       +
       	}

     

       382
       382
       +
       

     

       383
       383
       +
       	topics, err := rp.validator.ValidateRepoTopicStr(topicStr)

     

       384
       384
       +
       	if err != nil {

     

       385
       385
       +
       		l.Error("invalid topics", "err", err)

     

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

     

       387
       387
       +
       		return

     

       388
       388
       +
       	}

     

       389
       389
       +
       	l.Debug("got", "topicsStr", topicStr, "topics", topics)

     

       390
       390
       +
       

     

       391
       391
       +
       	newRepo := f.Repo

     

       392
       392
       +
       	newRepo.Description = description

     

       393
       393
       +
       	newRepo.Website = website

     

       394
       394
       +
       	newRepo.Topics = topics

     

       395
       395
       +
       	record := newRepo.AsRecord()

     

       396
       396
       +
       

     

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

     

       398
       398
       +
       	if err != nil {

     

       399
       399
       +
       		l.Error("failed to begin transaction", "err", err)

     

       400
       400
       +
       		rp.pages.Notice(w, noticeId, "Failed to save repository information.")

     

       401
       401
       +
       		return

     

       402
       402
       +
       	}

     

       403
       403
       +
       	defer tx.Rollback()

     

       404
       404
       +
       

     

       405
       405
       +
       	err = db.PutRepo(tx, newRepo)

     

       406
       406
       +
       	if err != nil {

     

       407
       407
       +
       		l.Error("failed to update repository", "err", err)

     

       408
       408
       +
       		rp.pages.Notice(w, noticeId, "Failed to save repository information.")

     

       409
       409
       +
       		return

     

       410
       410
       +
       	}

     

       411
       411
       +
       

     

       412
       412
       +
       	ex, err := comatproto.RepoGetRecord(r.Context(), client, "", tangled.RepoNSID, newRepo.Did, newRepo.Rkey)

     

       413
       413
       +
       	if err != nil {

     

       414
       414
       +
       		// failed to get record

     

       415
       415
       +
       		l.Error("failed to get repo record", "err", err)

     

       416
       416
       +
       		rp.pages.Notice(w, noticeId, "Failed to save repository information, no record found on PDS.")

     

       417
       417
       +
       		return

     

       418
       418
       +
       	}

     

       419
       419
       +
       	_, err = comatproto.RepoPutRecord(r.Context(), client, &comatproto.RepoPutRecord_Input{

     

       420
       420
       +
       		Collection: tangled.RepoNSID,

     

       421
       421
       +
       		Repo:       newRepo.Did,

     

       422
       422
       +
       		Rkey:       newRepo.Rkey,

     

       423
       423
       +
       		SwapRecord: ex.Cid,

     

       424
       424
       +
       		Record: &lexutil.LexiconTypeDecoder{

     

       425
       425
       +
       			Val: &record,

     

       426
       426
       +
       		},

     

       427
       427
       +
       	})

     

       428
       428
       +
       

     

       429
       429
       +
       	if err != nil {

     

       430
       430
       +
       		l.Error("failed to perferom update-repo query", "err", err)

     

       431
       431
       +
       		// failed to get record

     

       432
       432
       +
       		rp.pages.Notice(w, noticeId, "Failed to save repository information, unable to save to PDS.")

     

       433
       433
       +
       		return

     

       434
       434
       +
       	}

     

       435
       435
       +
       

     

       436
       436
       +
       	err = tx.Commit()

     

       437
       437
       +
       	if err != nil {

     

       438
       438
       +
       		l.Error("failed to commit", "err", err)

     

       439
       439
       +
       	}

     

       440
       440
       +
       

     

       441
       441
       +
       	rp.pages.HxRefresh(w)

     

       442
       442
       +
       }

+79

appview/repo/tags.go

···

       1
       1
       +
       package repo

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"encoding/json"

     

       5
       5
       +
       	"fmt"

     

       6
       6
       +
       	"net/http"

     

       7
       7
       +
       

     

       8
       8
       +
       	"tangled.org/core/api/tangled"

     

       9
       9
       +
       	"tangled.org/core/appview/db"

     

       10
       10
       +
       	"tangled.org/core/appview/models"

     

       11
       11
       +
       	"tangled.org/core/appview/pages"

     

       12
       12
       +
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       13
       13
       +
       	"tangled.org/core/types"

     

       14
       14
       +
       

     

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

     

       16
       16
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

       17
       17
       +
       )

     

       18
       18
       +
       

     

       19
       19
       +
       func (rp *Repo) Tags(w http.ResponseWriter, r *http.Request) {

     

       20
       20
       +
       	l := rp.logger.With("handler", "RepoTags")

     

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

     

       22
       22
       +
       	if err != nil {

     

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

     

       24
       24
       +
       		return

     

       25
       25
       +
       	}

     

       26
       26
       +
       	scheme := "http"

     

       27
       27
       +
       	if !rp.config.Core.Dev {

     

       28
       28
       +
       		scheme = "https"

     

       29
       29
       +
       	}

     

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

     

       31
       31
       +
       	xrpcc := &indigoxrpc.Client{

     

       32
       32
       +
       		Host: host,

     

       33
       33
       +
       	}

     

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

     

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

     

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

     

       37
       37
       +
       		l.Error("failed to call XRPC repo.tags", "err", xrpcerr)

     

       38
       38
       +
       		rp.pages.Error503(w)

     

       39
       39
       +
       		return

     

       40
       40
       +
       	}

     

       41
       41
       +
       	var result types.RepoTagsResponse

     

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

     

       43
       43
       +
       		l.Error("failed to decode XRPC response", "err", err)

     

       44
       44
       +
       		rp.pages.Error503(w)

     

       45
       45
       +
       		return

     

       46
       46
       +
       	}

     

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

     

       48
       48
       +
       	if err != nil {

     

       49
       49
       +
       		l.Error("failed grab artifacts", "err", err)

     

       50
       50
       +
       		return

     

       51
       51
       +
       	}

     

       52
       52
       +
       	// convert artifacts to map for easy UI building

     

       53
       53
       +
       	artifactMap := make(map[plumbing.Hash][]models.Artifact)

     

       54
       54
       +
       	for _, a := range artifacts {

     

       55
       55
       +
       		artifactMap[a.Tag] = append(artifactMap[a.Tag], a)

     

       56
       56
       +
       	}

     

       57
       57
       +
       	var danglingArtifacts []models.Artifact

     

       58
       58
       +
       	for _, a := range artifacts {

     

       59
       59
       +
       		found := false

     

       60
       60
       +
       		for _, t := range result.Tags {

     

       61
       61
       +
       			if t.Tag != nil {

     

       62
       62
       +
       				if t.Tag.Hash == a.Tag {

     

       63
       63
       +
       					found = true

     

       64
       64
       +
       				}

     

       65
       65
       +
       			}

     

       66
       66
       +
       		}

     

       67
       67
       +
       		if !found {

     

       68
       68
       +
       			danglingArtifacts = append(danglingArtifacts, a)

     

       69
       69
       +
       		}

     

       70
       70
       +
       	}

     

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

     

       72
       72
       +
       	rp.pages.RepoTags(w, pages.RepoTagsParams{

     

       73
       73
       +
       		LoggedInUser:      user,

     

       74
       74
       +
       		RepoInfo:          f.RepoInfo(user),

     

       75
       75
       +
       		RepoTagsResponse:  result,

     

       76
       76
       +
       		ArtifactMap:       artifactMap,

     

       77
       77
       +
       		DanglingArtifacts: danglingArtifacts,

     

       78
       78
       +
       	})

     

       79
       79
       +
       }

+107

appview/repo/tree.go

···

       1
       1
       +
       package repo

     

       2
       2
       +
       

     

       3
       3
       +
       import (

     

       4
       4
       +
       	"fmt"

     

       5
       5
       +
       	"net/http"

     

       6
       6
       +
       	"net/url"

     

       7
       7
       +
       	"strings"

     

       8
       8
       +
       	"time"

     

       9
       9
       +
       

     

       10
       10
       +
       	"tangled.org/core/api/tangled"

     

       11
       11
       +
       	"tangled.org/core/appview/pages"

     

       12
       12
       +
       	xrpcclient "tangled.org/core/appview/xrpcclient"

     

       13
       13
       +
       	"tangled.org/core/types"

     

       14
       14
       +
       

     

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

     

       16
       16
       +
       	"github.com/go-chi/chi/v5"

     

       17
       17
       +
       	"github.com/go-git/go-git/v5/plumbing"

     

       18
       18
       +
       )

     

       19
       19
       +
       

     

       20
       20
       +
       func (rp *Repo) Tree(w http.ResponseWriter, r *http.Request) {

     

       21
       21
       +
       	l := rp.logger.With("handler", "RepoTree")

     

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

     

       23
       23
       +
       	if err != nil {

     

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

     

       25
       25
       +
       		return

     

       26
       26
       +
       	}

     

       27
       27
       +
       	ref := chi.URLParam(r, "ref")

     

       28
       28
       +
       	ref, _ = url.PathUnescape(ref)

     

       29
       29
       +
       	// if the tree path has a trailing slash, let's strip it

     

       30
       30
       +
       	// so we don't 404

     

       31
       31
       +
       	treePath := chi.URLParam(r, "*")

     

       32
       32
       +
       	treePath, _ = url.PathUnescape(treePath)

     

       33
       33
       +
       	treePath = strings.TrimSuffix(treePath, "/")

     

       34
       34
       +
       	scheme := "http"

     

       35
       35
       +
       	if !rp.config.Core.Dev {

     

       36
       36
       +
       		scheme = "https"

     

       37
       37
       +
       	}

     

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

     

       39
       39
       +
       	xrpcc := &indigoxrpc.Client{

     

       40
       40
       +
       		Host: host,

     

       41
       41
       +
       	}

     

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

     

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

     

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

     

       45
       45
       +
       		l.Error("failed to call XRPC repo.tree", "err", xrpcerr)

     

       46
       46
       +
       		rp.pages.Error503(w)

     

       47
       47
       +
       		return

     

       48
       48
       +
       	}

     

       49
       49
       +
       	// Convert XRPC response to internal types.RepoTreeResponse

     

       50
       50
       +
       	files := make([]types.NiceTree, len(xrpcResp.Files))

     

       51
       51
       +
       	for i, xrpcFile := range xrpcResp.Files {

     

       52
       52
       +
       		file := types.NiceTree{

     

       53
       53
       +
       			Name:      xrpcFile.Name,

     

       54
       54
       +
       			Mode:      xrpcFile.Mode,

     

       55
       55
       +
       			Size:      int64(xrpcFile.Size),

     

       56
       56
       +
       			IsFile:    xrpcFile.Is_file,

     

       57
       57
       +
       			IsSubtree: xrpcFile.Is_subtree,

     

       58
       58
       +
       		}

     

       59
       59
       +
       		// Convert last commit info if present

     

       60
       60
       +
       		if xrpcFile.Last_commit != nil {

     

       61
       61
       +
       			commitWhen, _ := time.Parse(time.RFC3339, xrpcFile.Last_commit.When)

     

       62
       62
       +
       			file.LastCommit = &types.LastCommitInfo{

     

       63
       63
       +
       				Hash:    plumbing.NewHash(xrpcFile.Last_commit.Hash),

     

       64
       64
       +
       				Message: xrpcFile.Last_commit.Message,

     

       65
       65
       +
       				When:    commitWhen,

     

       66
       66
       +
       			}

     

       67
       67
       +
       		}

     

       68
       68
       +
       		files[i] = file

     

       69
       69
       +
       	}

     

       70
       70
       +
       	result := types.RepoTreeResponse{

     

       71
       71
       +
       		Ref:   xrpcResp.Ref,

     

       72
       72
       +
       		Files: files,

     

       73
       73
       +
       	}

     

       74
       74
       +
       	if xrpcResp.Parent != nil {

     

       75
       75
       +
       		result.Parent = *xrpcResp.Parent

     

       76
       76
       +
       	}

     

       77
       77
       +
       	if xrpcResp.Dotdot != nil {

     

       78
       78
       +
       		result.DotDot = *xrpcResp.Dotdot

     

       79
       79
       +
       	}

     

       80
       80
       +
       	if xrpcResp.Readme != nil {

     

       81
       81
       +
       		result.ReadmeFileName = xrpcResp.Readme.Filename

     

       82
       82
       +
       		result.Readme = xrpcResp.Readme.Contents

     

       83
       83
       +
       	}

     

       84
       84
       +
       	// redirects tree paths trying to access a blob; in this case the result.Files is unpopulated,

     

       85
       85
       +
       	// so we can safely redirect to the "parent" (which is the same file).

     

       86
       86
       +
       	if len(result.Files) == 0 && result.Parent == treePath {

     

       87
       87
       +
       		redirectTo := fmt.Sprintf("/%s/blob/%s/%s", f.OwnerSlashRepo(), url.PathEscape(ref), result.Parent)

     

       88
       88
       +
       		http.Redirect(w, r, redirectTo, http.StatusFound)

     

       89
       89
       +
       		return

     

       90
       90
       +
       	}

     

       91
       91
       +
       	user := rp.oauth.GetUser(r)

     

       92
       92
       +
       	var breadcrumbs [][]string

     

       93
       93
       +
       	breadcrumbs = append(breadcrumbs, []string{f.Name, fmt.Sprintf("/%s/tree/%s", f.OwnerSlashRepo(), url.PathEscape(ref))})

     

       94
       94
       +
       	if treePath != "" {

     

       95
       95
       +
       		for idx, elem := range strings.Split(treePath, "/") {

     

       96
       96
       +
       			breadcrumbs = append(breadcrumbs, []string{elem, fmt.Sprintf("%s/%s", breadcrumbs[idx][1], url.PathEscape(elem))})

     

       97
       97
       +
       		}

     

       98
       98
       +
       	}

     

       99
       99
       +
       	sortFiles(result.Files)

     

       100
       100
       +
       	rp.pages.RepoTree(w, pages.RepoTreeParams{

     

       101
       101
       +
       		LoggedInUser:     user,

     

       102
       102
       +
       		BreadCrumbs:      breadcrumbs,

     

       103
       103
       +
       		TreePath:         treePath,

     

       104
       104
       +
       		RepoInfo:         f.RepoInfo(user),

     

       105
       105
       +
       		RepoTreeResponse: result,

     

       106
       106
       +
       	})

     

       107
       107
       +
       }