commit 45f167d35f15790e11907ef08d5a4e9d67c3eb98 · foxwitch.net/core

+25 -3

appview/pages/pages.go

···

       127
       127
        
       	return p.execute("user/profile", w, params)

     

       128
       128
        
       }

     

       129
       129
        
       

     

       130
       130
       +
       type RepoInfo struct {

     

       131
       131
       +
       	Name        string

     

       132
       132
       +
       	OwnerDid    string

     

       133
       133
       +
       	OwnerHandle string

     

       134
       134
       +
       }

     

       135
       135
       +
       

     

       136
       136
       +
       func (r RepoInfo) OwnerWithAt() string {

     

       137
       137
       +
       	if r.OwnerHandle != "" {

     

       138
       138
       +
       		return fmt.Sprintf("@%s", r.OwnerHandle)

     

       139
       139
       +
       	} else {

     

       140
       140
       +
       		return r.OwnerDid

     

       141
       141
       +
       	}

     

       142
       142
       +
       }

     

       143
       143
       +
       

     

       130
       144
        
       type RepoIndexParams struct {

     

       131
       145
        
       	LoggedInUser *auth.User

     

       132
       132
       -
       	Name         string

     

       133
       133
       -
       	UserDid      string

     

       134
       134
       -
       	UserHandle   string

     

       146
       146
       +
       	RepoInfo     RepoInfo

     

       135
       147
        
       	types.RepoIndexResponse

     

       136
       148
        
       }

     

       137
       149
        
       

     

       138
       150
        
       func (p *Pages) RepoIndexPage(w io.Writer, params RepoIndexParams) error {

     

       139
       151
        
       	return p.execute("repo/index", w, params)

     

       140
       152
        
       }

     

       153
       153
       +
       

     

       154
       154
       +
       type RepoLogParams struct {

     

       155
       155
       +
       	LoggedInUser *auth.User

     

       156
       156
       +
       	RepoInfo     RepoInfo

     

       157
       157
       +
       	types.RepoLogResponse

     

       158
       158
       +
       }

     

       159
       159
       +
       

     

       160
       160
       +
       func (p *Pages) RepoLog(w io.Writer, params RepoLogParams) error {

     

       161
       161
       +
       	return p.execute("repo/log", w, params)

     

       162
       162
       +
       }

+4 -10

appview/pages/templates/repo/index.html

···

       1
       1
       -
       {{define "title"}} {{ or .UserHandle .UserDid }} / {{ .Name }} {{end}}

     

       1
       1
       +
       {{define "title"}} {{ .RepoInfo.OwnerWithAt }} / {{ .RepoInfo.Name }} {{end}}

     

       2
       2
        
       

     

       3
       3
        
       {{define "content"}}

     

       4
       4
       -
       {{- $id := "" -}}

     

       5
       5
       -
       {{- if .UserHandle -}}

     

       6
       6
       -
         {{- $id = printf "@%s" .UserHandle -}}

     

       7
       7
       -
       {{- else -}}

     

       8
       8
       -
         {{- $id = .UserDid -}}

     

       9
       9
       -
       {{- end -}}

     

       10
       4
        
       

     

       11
       5
        
       <h1>

     

       12
       12
       -
       {{ $id }} / {{ .Name }}

     

       6
       6
       +
       {{ .RepoInfo.OwnerWithAt }} / {{ .RepoInfo.Name }}

     

       13
       7
        
       </h1>

     

       14
       8
        
           <main>

     

       15
       9
        
             <div class="log">

     

       16
       10
        
               {{ range .Commits }}

     

       17
       11
        
               <div>

     

       18
       18
       -
                 <div><a href="/{{ $id }}/{{ $.Name }}/commit/{{ .Hash.String }}" class="commit-hash">{{ slice .Hash.String 0 8 }}</a></div>

     

       12
       12
       +
                 <div><a href="/{{ $.RepoInfo.OwnerWithAt }}/{{ $.RepoInfo.Name }}/commit/{{ .Hash.String }}" class="commit-hash">{{ slice .Hash.String 0 8 }}</a></div>

     

       19
       13
        
                 <pre>{{ .Message }}</pre>

     

       20
       14
        
               </div>

     

       21
       15
        
               <div class="commit-info">

     
···

       33
       27
        
             <div class="clone-url">

     

       34
       28
        
             <strong>clone</strong>

     

       35
       29
        
               <pre>

     

       36
       36
       -
       git clone https://tangled.sh/{{ $id }}/{{ .Name }}

     

       30
       30
       +
       git clone https://tangled.sh/{{ .RepoInfo.OwnerWithAt }}/{{ .RepoInfo.Name }}

     

       37
       31
        
               </pre>

     

       38
       32
        
             </div>

     

       39
       33
        
           </main>

+9 -10

appview/pages/templates/repo/log.html

···

       1
       1
       -
       <html>

     

       2
       2
       -
       {{ template "layouts/head" . }}

     

       1
       1
       +
       {{define "title"}} log | {{ .RepoInfo.OwnerWithAt }} / {{ .RepoInfo.Name }} {{end}}

     

       3
       2
        
       

     

       4
       4
       -
         {{ template "layouts/repo-header" . }}

     

       5
       5
       -
         <body>

     

       6
       6
       -
           {{ template "layouts/nav" . }}

     

       3
       3
       +
       {{define "content"}}

     

       4
       4
       +
       

     

       5
       5
       +
       <h1>

     

       6
       6
       +
       log | {{ .RepoInfo.OwnerWithAt }} / {{ .RepoInfo.Name }}

     

       7
       7
       +
       </h1>

     

       7
       8
        
           <main>

     

       8
       8
       -
             {{ $repo := .name }}

     

       9
       9
        
             <div class="log">

     

       10
       10
       -
               {{ range .commits }}

     

       10
       10
       +
               {{ range .Commits }}

     

       11
       11
        
               <div>

     

       12
       12
       -
                 <div><a href="/{{ $repo }}/commit/{{ .Hash.String }}" class="commit-hash">{{ slice .Hash.String 0 8 }}</a></div>

     

       12
       12
       +
                 <div><a href="/{{ $.RepoInfo.OwnerWithAt }}/{{ $.RepoInfo.Name }}/commit/{{ .Hash.String }}" class="commit-hash">{{ slice .Hash.String 0 8 }}</a></div>

     

       13
       13
        
                 <pre>{{ .Message }}</pre>

     

       14
       14
        
               </div>

     

       15
       15
        
               <div class="commit-info">

     
···

       19
       19
        
               {{ end }}

     

       20
       20
        
             </div>

     

       21
       21
        
           </main>

     

       22
       22
       -
         </body>

     

       23
       23
       -
       </html>

     

       22
       22
       +
       {{end}}

+64 -20

appview/state/repo.go

···

       14
       14
        
       )

     

       15
       15
        
       

     

       16
       16
        
       func (s *State) RepoIndex(w http.ResponseWriter, r *http.Request) {

     

       17
       17
       -
       	ctx := r.Context()

     

       18
       18
       -
       	repoName := chi.URLParam(r, "repo")

     

       19
       19
       -
       

     

       20
       20
       -
       	knot, ok := ctx.Value("knot").(string)

     

       21
       21
       -
       	if !ok {

     

       22
       22
       -
       		log.Println("malformed middleware")

     

       23
       23
       -
       		w.WriteHeader(http.StatusInternalServerError)

     

       24
       24
       -
       		return

     

       25
       25
       -
       	}

     

       26
       26
       -
       

     

       27
       27
       -
       	id, ok := ctx.Value("resolvedId").(identity.Identity)

     

       28
       28
       -
       	if !ok {

     

       29
       29
       -
       		log.Println("malformed middleware")

     

       30
       30
       -
       		w.WriteHeader(http.StatusInternalServerError)

     

       17
       17
       +
       	repoName, knot, id, err := repoKnotAndId(r)

     

       18
       18
       +
       	if err != nil {

     

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

     

       31
       20
        
       		return

     

       32
       21
        
       	}

     

       33
       22
        
       

     
···

       38
       27
        
       	}

     

       39
       28
        
       	defer resp.Body.Close()

     

       40
       29
        
       

     

       41
       41
       -
       	// Read the response body

     

       42
       30
        
       	body, err := io.ReadAll(resp.Body)

     

       43
       31
        
       	if err != nil {

     

       44
       32
        
       		log.Fatalf("Error reading response body: %v", err)

     
···

       54
       42
        
       

     

       55
       43
        
       	log.Println(resp.Status, result)

     

       56
       44
        
       

     

       57
       57
       -
       	user := s.auth.GetUser(r)

     

       58
       45
        
       	s.pages.RepoIndexPage(w, pages.RepoIndexParams{

     

       59
       59
       -
       		LoggedInUser:      user,

     

       60
       60
       -
       		UserDid:           id.DID.String(),

     

       61
       61
       -
       		UserHandle:        id.Handle.String(),

     

       62
       62
       -
       		Name:              repoName,

     

       46
       46
       +
       		LoggedInUser: s.auth.GetUser(r),

     

       47
       47
       +
       		RepoInfo: pages.RepoInfo{

     

       48
       48
       +
       			OwnerDid:    id.DID.String(),

     

       49
       49
       +
       			OwnerHandle: id.Handle.String(),

     

       50
       50
       +
       			Name:        repoName,

     

       51
       51
       +
       		},

     

       63
       52
        
       		RepoIndexResponse: result,

     

       64
       53
        
       	})

     

       65
       54
        
       

     

       66
       55
        
       	return

     

       67
       56
        
       }

     

       57
       57
       +
       

     

       58
       58
       +
       func (s *State) RepoLog(w http.ResponseWriter, r *http.Request) {

     

       59
       59
       +
       	repoName, knot, id, err := repoKnotAndId(r)

     

       60
       60
       +
       	if err != nil {

     

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

     

       62
       62
       +
       		return

     

       63
       63
       +
       	}

     

       64
       64
       +
       

     

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

     

       66
       66
       +
       	resp, err := http.Get(fmt.Sprintf("http://%s/%s/%s/log/%s", knot, id.DID.String(), repoName, ref))

     

       67
       67
       +
       	if err != nil {

     

       68
       68
       +
       		log.Println("failed to reach knotserver", err)

     

       69
       69
       +
       		return

     

       70
       70
       +
       	}

     

       71
       71
       +
       

     

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

     

       73
       73
       +
       	if err != nil {

     

       74
       74
       +
       		log.Fatalf("Error reading response body: %v", err)

     

       75
       75
       +
       		return

     

       76
       76
       +
       	}

     

       77
       77
       +
       

     

       78
       78
       +
       	var result types.RepoLogResponse

     

       79
       79
       +
       	err = json.Unmarshal(body, &result)

     

       80
       80
       +
       	if err != nil {

     

       81
       81
       +
       		log.Println("failed to parse json response", err)

     

       82
       82
       +
       		return

     

       83
       83
       +
       	}

     

       84
       84
       +
       

     

       85
       85
       +
       	s.pages.RepoLog(w, pages.RepoLogParams{

     

       86
       86
       +
       		LoggedInUser: s.auth.GetUser(r),

     

       87
       87
       +
       		RepoInfo: pages.RepoInfo{

     

       88
       88
       +
       			OwnerDid:    id.DID.String(),

     

       89
       89
       +
       			OwnerHandle: id.Handle.String(),

     

       90
       90
       +
       			Name:        repoName,

     

       91
       91
       +
       		},

     

       92
       92
       +
       		RepoLogResponse: result,

     

       93
       93
       +
       	})

     

       94
       94
       +
       	return

     

       95
       95
       +
       }

     

       96
       96
       +
       

     

       97
       97
       +
       func repoKnotAndId(r *http.Request) (string, string, identity.Identity, error) {

     

       98
       98
       +
       	repoName := chi.URLParam(r, "repo")

     

       99
       99
       +
       	knot, ok := r.Context().Value("knot").(string)

     

       100
       100
       +
       	if !ok {

     

       101
       101
       +
       		log.Println("malformed middleware")

     

       102
       102
       +
       		return "", "", identity.Identity{}, fmt.Errorf("malformed middleware")

     

       103
       103
       +
       	}

     

       104
       104
       +
       	id, ok := r.Context().Value("resolvedId").(identity.Identity)

     

       105
       105
       +
       	if !ok {

     

       106
       106
       +
       		log.Println("malformed middleware")

     

       107
       107
       +
       		return "", "", identity.Identity{}, fmt.Errorf("malformed middleware")

     

       108
       108
       +
       	}

     

       109
       109
       +
       

     

       110
       110
       +
       	return repoName, knot, id, nil

     

       111
       111
       +
       }

-14

appview/state/signer.go

···

       113
       113
        
       

     

       114
       114
        
       	return s.client.Do(req)

     

       115
       115
        
       }

     

       116
       116
       -
       

     

       117
       117
       -
       func (s *SignedClient) RepoIndex(did, repo string) (*http.Response, error) {

     

       118
       118
       -
       	const (

     

       119
       119
       -
       		Method = "GET"

     

       120
       120
       -
       	)

     

       121
       121
       -
       	endpoint := fmt.Sprint("/%s/%s", did, repo)

     

       122
       122
       -
       

     

       123
       123
       -
       	req, err := s.newRequest(Method, endpoint, nil)

     

       124
       124
       -
       	if err != nil {

     

       125
       125
       -
       		return nil, err

     

       126
       126
       -
       	}

     

       127
       127
       -
       

     

       128
       128
       -
       	return s.client.Do(req)

     

       129
       129
       -
       }

+3

appview/state/state.go

···

       601
       601
        
       		r.Get("/", s.ProfilePage)

     

       602
       602
        
       		r.With(ResolveRepoKnot(s)).Route("/{repo}", func(r chi.Router) {

     

       603
       603
        
       			r.Get("/", s.RepoIndex)

     

       604
       604
       +
       			r.Get("/log/{ref}", s.RepoLog)

     

       605
       605
       +
       

     

       604
       606
        
       			// These routes get proxied to the knot

     

       605
       607
        
       			r.Get("/info/refs", s.InfoRefs)

     

       606
       608
        
       			r.Post("/git-upload-pack", s.UploadPack)

     

       609
       609
       +
       

     

       607
       610
        
       		})

     

       608
       611
        
       	})

     

       609
       612

+10 -9

knotserver/routes.go

···

       266
       266
        
       		commits = commits[start:end]

     

       267
       267
        
       	}

     

       268
       268
        
       

     

       269
       269
       -
       	data := make(map[string]interface{})

     

       270
       270
       -
       	data["commits"] = commits

     

       271
       271
       -
       	data["ref"] = ref

     

       272
       272
       -
       	data["desc"] = getDescription(path)

     

       273
       273
       -
       	data["log"] = true

     

       274
       274
       -
       	data["total"] = total

     

       275
       275
       -
       	data["page"] = page

     

       276
       276
       -
       	data["per_page"] = pageSize

     

       269
       269
       +
       	resp := types.RepoLogResponse{

     

       270
       270
       +
       		Commits:     commits,

     

       271
       271
       +
       		Ref:         ref,

     

       272
       272
       +
       		Description: getDescription(path),

     

       273
       273
       +
       		Log:         true,

     

       274
       274
       +
       		Total:       total,

     

       275
       275
       +
       		Page:        page,

     

       276
       276
       +
       		PerPage:     pageSize,

     

       277
       277
       +
       	}

     

       277
       278
        
       

     

       278
       278
       -
       	writeJSON(w, data)

     

       279
       279
       +
       	writeJSON(w, resp)

     

       279
       280
        
       	return

     

       280
       281
        
       }

     

       281
       282

+10

types/repo.go

···

       13
       13
        
       	Commits     []*object.Commit `json:"commits,omitempty"`

     

       14
       14
        
       	Description string           `json:"description,omitempty"`

     

       15
       15
        
       }

     

       16
       16
       +
       

     

       17
       17
       +
       type RepoLogResponse struct {

     

       18
       18
       +
       	Commits     []*object.Commit `json:"commits,omitempty"`

     

       19
       19
       +
       	Ref         string           `json:"ref,omitempty"`

     

       20
       20
       +
       	Description string           `json:"description,omitempty"`

     

       21
       21
       +
       	Log         bool             `json:"log,omitempty"`

     

       22
       22
       +
       	Total       int              `json:"total,omitempty"`

     

       23
       23
       +
       	Page        int              `json:"page,omitempty"`

     

       24
       24
       +
       	PerPage     int              `json:"per_page,omitempty"`

     

       25
       25
       +
       }