interdiff of round #2 and #1 · pull #800 · tangled.org/core

REVERTED

appview/service/issue/context.go

···

       1
       -
       package issue

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"context"

     

       5
       -
       

     

       6
       -
       	"tangled.org/core/appview/models"

     

       7
       -
       )

     

       8
       -
       

     

       9
       -
       type ctxKey struct{}

     

       10
       -
       

     

       11
       -
       func IntoContext(ctx context.Context, repo *models.Issue) context.Context {

     

       12
       -
       	return context.WithValue(ctx, ctxKey{}, repo)

     

       13
       -
       }

     

       14
       -
       

     

       15
       -
       func FromContext(ctx context.Context) (*models.Issue, bool) {

     

       16
       -
       	repo, ok := ctx.Value(ctxKey{}).(*models.Issue)

     

       17
       -
       	return repo, ok

     

       18
       -
       }

ERROR

appview/service/issue/issue.go

Failed to calculate interdiff for this file.

ERROR

appview/service/issue/state.go

Failed to calculate interdiff for this file.

REVERTED

appview/service/owner/context.go

···

       1
       -
       package owner

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"context"

     

       5
       -
       

     

       6
       -
       	"github.com/bluesky-social/indigo/atproto/identity"

     

       7
       -
       )

     

       8
       -
       

     

       9
       -
       type ctxKey struct{}

     

       10
       -
       

     

       11
       -
       func IntoContext(ctx context.Context, id *identity.Identity) context.Context {

     

       12
       -
       	return context.WithValue(ctx, ctxKey{}, id)

     

       13
       -
       }

     

       14
       -
       

     

       15
       -
       func FromContext(ctx context.Context) (*identity.Identity, bool) {

     

       16
       -
       	repo, ok := ctx.Value(ctxKey{}).(*identity.Identity)

     

       17
       -
       	return repo, ok

     

       18
       -
       }

REVERTED

appview/service/repo/context.go

···

       1
       -
       package repo

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"context"

     

       5
       -
       

     

       6
       -
       	"tangled.org/core/appview/models"

     

       7
       -
       )

     

       8
       -
       

     

       9
       -
       type ctxKey struct{}

     

       10
       -
       

     

       11
       -
       func IntoContext(ctx context.Context, repo *models.Repo) context.Context {

     

       12
       -
       	return context.WithValue(ctx, ctxKey{}, repo)

     

       13
       -
       }

     

       14
       -
       

     

       15
       -
       func FromContext(ctx context.Context) (*models.Repo, bool) {

     

       16
       -
       	repo, ok := ctx.Value(ctxKey{}).(*models.Repo)

     

       17
       -
       	return repo, ok

     

       18
       -
       }

ERROR

appview/service/repo/repo.go

Failed to calculate interdiff for this file.

REVERTED

appview/state/router.go

···

       18
        
       	"tangled.org/core/appview/spindles"

     

       19
        
       	"tangled.org/core/appview/state/userutil"

     

       20
        
       	avstrings "tangled.org/core/appview/strings"

     

       21
       -
       	"tangled.org/core/appview/web"

     

       22
        
       	"tangled.org/core/log"

     

       23
        
       )

     

       24
        
       

     
···

       41
        
       	userRouter := s.UserRouter(&middleware)

     

       42
        
       	standardRouter := s.StandardRouter(&middleware)

     

       43
        
       

     

       44
       -
       	_ = web.UserRouter(

     

       45
       -
       		s.logger,

     

       46
       -
       		s.config,

     

       47
       -
       		s.db,

     

       48
       -
       		s.idResolver,

     

       49
       -
       		s.refResolver,

     

       50
       -
       		s.notifier,

     

       51
       -
       		s.oauth,

     

       52
       -
       		s.pages,

     

       53
       -
       	)

     

       54
       -
       

     

       55
        
       	router.HandleFunc("/*", func(w http.ResponseWriter, r *http.Request) {

     

       56
        
       		pat := chi.URLParam(r, "*")

     

       57
        
       		pathParts := strings.SplitN(pat, "/", 2)

···

       18
        
       	"tangled.org/core/appview/spindles"

     

       19
        
       	"tangled.org/core/appview/state/userutil"

     

       20
        
       	avstrings "tangled.org/core/appview/strings"

     

       0
        
       
     

       21
        
       	"tangled.org/core/log"

     

       22
        
       )

     

       23
        
       

     
···

       40
        
       	userRouter := s.UserRouter(&middleware)

     

       41
        
       	standardRouter := s.StandardRouter(&middleware)

     

       42
        
       

     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       0
        
       
     

       43
        
       	router.HandleFunc("/*", func(w http.ResponseWriter, r *http.Request) {

     

       44
        
       		pat := chi.URLParam(r, "*")

     

       45
        
       		pathParts := strings.SplitN(pat, "/", 2)

REVERTED

appview/web/handler/issues.go

···

       1
       -
       package handler

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"net/http"

     

       5
       -
       

     

       6
       -
       	"tangled.org/core/appview/service/issue"

     

       7
       -
       )

     

       8
       -
       

     

       9
       -
       func RepoIssues(s issue.IssueService) http.HandlerFunc {

     

       10
       -
       	return func(w http.ResponseWriter, r *http.Request) {

     

       11
       -
       	}

     

       12
       -
       }

REVERTED

appview/web/handler/issues_issue.go

···

       1
       -
       package handler

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"net/http"

     

       5
       -
       

     

       6
       -
       	"tangled.org/core/appview/pages"

     

       7
       -
       	isvc "tangled.org/core/appview/service/issue"

     

       8
       -
       	"tangled.org/core/log"

     

       9
       -
       )

     

       10
       -
       

     

       11
       -
       func Issue(s isvc.IssueService) http.HandlerFunc {

     

       12
       -
       	return func(w http.ResponseWriter, r *http.Request) {

     

       13
       -
       		panic("unimplemented")

     

       14
       -
       	}

     

       15
       -
       }

     

       16
       -
       

     

       17
       -
       func IssueDelete(s isvc.IssueService, p *pages.Pages) http.HandlerFunc {

     

       18
       -
       	noticeId := "issue-actions-error"

     

       19
       -
       	return func(w http.ResponseWriter, r *http.Request) {

     

       20
       -
       		ctx := r.Context()

     

       21
       -
       		l := log.FromContext(ctx).With("handler", "IssueDelete")

     

       22
       -
       		issue, ok := isvc.FromContext(ctx)

     

       23
       -
       		if !ok {

     

       24
       -
       			l.Error("failed to get issue")

     

       25
       -
       			// TODO: 503 error with more detailed messages

     

       26
       -
       			p.Error503(w)

     

       27
       -
       			return

     

       28
       -
       		}

     

       29
       -
       		err := s.DeleteIssue(ctx, issue)

     

       30
       -
       		if err != nil {

     

       31
       -
       			p.Notice(w, noticeId, "failed to delete issue")

     

       32
       -
       		}

     

       33
       -
       		p.HxLocation(w, "/")

     

       34
       -
       	}

     

       35
       -
       }

REVERTED

appview/web/handler/issues_issue_close.go

···

       1
       -
       package handler

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"net/http"

     

       5
       -
       

     

       6
       -
       	"tangled.org/core/appview/service/issue"

     

       7
       -
       )

     

       8
       -
       

     

       9
       -
       func CloseIssue(s issue.IssueService) http.HandlerFunc {

     

       10
       -
       	return func(w http.ResponseWriter, r *http.Request) {

     

       11
       -
       		panic("unimplemented")

     

       12
       -
       	}

     

       13
       -
       }

REVERTED

appview/web/handler/issues_issue_edit.go

···

       1
       -
       package handler

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"net/http"

     

       5
       -
       

     

       6
       -
       	"tangled.org/core/appview/service/issue"

     

       7
       -
       )

     

       8
       -
       

     

       9
       -
       func IssueEdit(s issue.IssueService) http.HandlerFunc {

     

       10
       -
       	return func(w http.ResponseWriter, r *http.Request) {

     

       11
       -
       		panic("unimplemented")

     

       12
       -
       	}

     

       13
       -
       }

     

       14
       -
       

     

       15
       -
       func IssueEditPost(s issue.IssueService) http.HandlerFunc {

     

       16
       -
       	return func(w http.ResponseWriter, r *http.Request) {

     

       17
       -
       		panic("unimplemented")

     

       18
       -
       	}

     

       19
       -
       }

REVERTED

appview/web/handler/issues_issue_opengraph.go

···

       1
       -
       package handler

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"net/http"

     

       5
       -
       

     

       6
       -
       	"tangled.org/core/appview/service/issue"

     

       7
       -
       )

     

       8
       -
       

     

       9
       -
       func IssueOpenGraph(s issue.IssueService) http.HandlerFunc {

     

       10
       -
       	return func(w http.ResponseWriter, r *http.Request) {

     

       11
       -
       		panic("unimplemented")

     

       12
       -
       	}

     

       13
       -
       }

REVERTED

appview/web/handler/issues_issue_reopen.go

···

       1
       -
       package handler

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"net/http"

     

       5
       -
       

     

       6
       -
       	"tangled.org/core/appview/service/issue"

     

       7
       -
       )

     

       8
       -
       

     

       9
       -
       func ReopenIssue(s issue.IssueService) http.HandlerFunc {

     

       10
       -
       	return func(w http.ResponseWriter, r *http.Request) {

     

       11
       -
       		panic("unimplemented")

     

       12
       -
       	}

     

       13
       -
       }

REVERTED

appview/web/handler/issues_new.go

···

       1
       -
       package handler

     

       2
       -
       

     

       3
       -
       import (

     

       4
       -
       	"errors"

     

       5
       -
       	"net/http"

     

       6
       -
       

     

       7
       -
       	"tangled.org/core/appview/pages"

     

       8
       -
       	isvc "tangled.org/core/appview/service/issue"

     

       9
       -
       	"tangled.org/core/appview/service/repo"

     

       10
       -
       	"tangled.org/core/log"

     

       11
       -
       )

     

       12
       -
       

     

       13
       -
       func NewIssue(p *pages.Pages) http.HandlerFunc {

     

       14
       -
       	return func(w http.ResponseWriter, r *http.Request) {

     

       15
       -
       		// TODO: render page

     

       16
       -
       	}

     

       17
       -
       }

     

       18
       -
       

     

       19
       -
       func NewIssuePost(is isvc.IssueService, p *pages.Pages) http.HandlerFunc {

     

       20
       -
       	noticeId := "issues"

     

       21
       -
       	return func(w http.ResponseWriter, r *http.Request) {

     

       22
       -
       		ctx := r.Context()

     

       23
       -
       		l := log.FromContext(ctx).With("handler", "NewIssuePost")

     

       24
       -
       		repo, ok := repo.FromContext(ctx)

     

       25
       -
       		if !ok {

     

       26
       -
       			l.Error("failed to get repo")

     

       27
       -
       			// TODO: 503 error with more detailed messages

     

       28
       -
       			p.Error503(w)

     

       29
       -
       			return

     

       30
       -
       		}

     

       31
       -
       		var (

     

       32
       -
       			title = r.FormValue("title")

     

       33
       -
       			body  = r.FormValue("body")

     

       34
       -
       		)

     

       35
       -
       

     

       36
       -
       		_, err := is.NewIssue(ctx, repo, title, body)

     

       37
       -
       		if err != nil {

     

       38
       -
       			if errors.Is(err, isvc.ErrDatabaseFail) {

     

       39
       -
       				p.Notice(w, noticeId, "Failed to create issue.")

     

       40
       -
       			} else if errors.Is(err, isvc.ErrPDSFail) {

     

       41
       -
       				p.Notice(w, noticeId, "Failed to create issue.")

     

       42
       -
       			} else {

     

       43
       -
       				p.Notice(w, noticeId, "Failed to create issue.")

     

       44
       -
       			}

     

       45
       -
       		}

     

       46
       -
       		p.HxLocation(w, "/")

     

       47
       -
       	}

     

       48
       -
       }

REVERTED

appview/web/handler/repos_new.go

···

       1
       -
       package handler

···

       0

REVERTED

appview/web/handler/repos_repo.go

···

       1
       -
       package handler

     

       2
       -

REVERTED

appview/web/handler/repos_repo_opengraph.go

···

       1
       -
       package handler

     

       2
       -

ERROR

appview/web/middleware/auth.go

Failed to calculate interdiff for this file.

ERROR

appview/web/middleware/log.go

Failed to calculate interdiff for this file.

ERROR

appview/web/middleware/middleware.go

Failed to calculate interdiff for this file.

ERROR

appview/web/middleware/paginate.go

Failed to calculate interdiff for this file.

ERROR

appview/web/middleware/resolve.go

Failed to calculate interdiff for this file.

ERROR

appview/web/routes.go

Failed to calculate interdiff for this file.

NEW

appview/oauth/handler.go

···

       24
        
       

     

       25
        
       	r.Get("/oauth/client-metadata.json", o.clientMetadata)

     

       26
        
       	r.Get("/oauth/jwks.json", o.jwks)

     

       27
       -
       	r.Get("/oauth/callback", o.callback)

     

       28
        
       	return r

     

       29
        
       }

     

       30
        
       

     
···

       50
        
       	}

     

       51
        
       }

     

       52
        
       

     

       53
       -
       func (o *OAuth) callback(w http.ResponseWriter, r *http.Request) {

     

       54
        
       	ctx := r.Context()

     

       55
        
       	l := o.Logger.With("query", r.URL.Query())

     

       56

···

       24
        
       

     

       25
        
       	r.Get("/oauth/client-metadata.json", o.clientMetadata)

     

       26
        
       	r.Get("/oauth/jwks.json", o.jwks)

     

       27
       +
       	r.Get("/oauth/callback", o.Callback)

     

       28
        
       	return r

     

       29
        
       }

     

       30
        
       

     
···

       50
        
       	}

     

       51
        
       }

     

       52
        
       

     

       53
       +
       func (o *OAuth) Callback(w http.ResponseWriter, r *http.Request) {

     

       54
        
       	ctx := r.Context()

     

       55
        
       	l := o.Logger.With("query", r.URL.Query())

     

       56

NEW

appview/oauth/session.go

···

       1
       +
       package oauth

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"net/http"

     

       5
       +
       

     

       6
       +
       	"github.com/bluesky-social/indigo/atproto/auth/oauth"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       func (o *OAuth) SaveSession2(w http.ResponseWriter, r *http.Request, sessData *oauth.ClientSessionData) {

     

       10
       +
       }

NEW

appview/service/repo/repoinfo.go

···

       1
       +
       package repo

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"context"

     

       5
       +
       

     

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

     

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

     

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

     

       9
       +
       	"tangled.org/core/appview/pages/repoinfo"

     

       10
       +
       )

     

       11
       +
       

     

       12
       +
       // GetRepoInfo converts given `Repo` to `RepoInfo` object.

     

       13
       +
       // The `user` can be nil.

     

       14
       +
       func (s *Service) GetRepoInfo(ctx context.Context, baseRepo *models.Repo, user *oauth.User) (*repoinfo.RepoInfo, error) {

     

       15
       +
       	var (

     

       16
       +
       		repoAt    = baseRepo.RepoAt()

     

       17
       +
       		isStarred = false

     

       18
       +
       		roles     = repoinfo.RolesInRepo{}

     

       19
       +
       	)

     

       20
       +
       	if user != nil {

     

       21
       +
       		isStarred = db.GetStarStatus(s.db, user.Did, repoAt)

     

       22
       +
       		roles.Roles = s.enforcer.GetPermissionsInRepo(user.Did, baseRepo.Knot, baseRepo.DidSlashRepo())

     

       23
       +
       	}

     

       24
       +
       

     

       25
       +
       	stats := baseRepo.RepoStats

     

       26
       +
       	if stats == nil {

     

       27
       +
       		starCount, err := db.GetStarCount(s.db, repoAt)

     

       28
       +
       		if err != nil {

     

       29
       +
       			return nil, err

     

       30
       +
       		}

     

       31
       +
       		issueCount, err := db.GetIssueCount(s.db, repoAt)

     

       32
       +
       		if err != nil {

     

       33
       +
       			return nil, err

     

       34
       +
       		}

     

       35
       +
       		pullCount, err := db.GetPullCount(s.db, repoAt)

     

       36
       +
       		if err != nil {

     

       37
       +
       			return nil, err

     

       38
       +
       		}

     

       39
       +
       		stats = &models.RepoStats{

     

       40
       +
       			StarCount:  starCount,

     

       41
       +
       			IssueCount: issueCount,

     

       42
       +
       			PullCount:  pullCount,

     

       43
       +
       		}

     

       44
       +
       	}

     

       45
       +
       

     

       46
       +
       	var sourceRepo *models.Repo

     

       47
       +
       	var err error

     

       48
       +
       	if baseRepo.Source != "" {

     

       49
       +
       		sourceRepo, err = db.GetRepoByAtUri(s.db, baseRepo.Source)

     

       50
       +
       		if err != nil {

     

       51
       +
       			return nil, err

     

       52
       +
       		}

     

       53
       +
       	}

     

       54
       +
       

     

       55
       +
       	repoInfo := &repoinfo.RepoInfo{

     

       56
       +
       		// ok this is basically a models.Repo

     

       57
       +
       		OwnerDid:    baseRepo.Did,

     

       58
       +
       		OwnerHandle: "", // TODO: shouldn't use

     

       59
       +
       		Name:        baseRepo.Name,

     

       60
       +
       		Rkey:        baseRepo.Rkey,

     

       61
       +
       		Description: baseRepo.Description,

     

       62
       +
       		Website:     baseRepo.Website,

     

       63
       +
       		Topics:      baseRepo.Topics,

     

       64
       +
       		Knot:        baseRepo.Knot,

     

       65
       +
       		Spindle:     baseRepo.Spindle,

     

       66
       +
       		Stats:       *stats,

     

       67
       +
       

     

       68
       +
       		// fork repo upstream

     

       69
       +
       		Source: sourceRepo,

     

       70
       +
       

     

       71
       +
       		// repo path (context)

     

       72
       +
       		CurrentDir: "",

     

       73
       +
       		Ref:        "",

     

       74
       +
       

     

       75
       +
       		// info related to the session

     

       76
       +
       		IsStarred: isStarred,

     

       77
       +
       		Roles:     roles,

     

       78
       +
       	}

     

       79
       +
       

     

       80
       +
       	return repoInfo, nil

     

       81
       +
       }

NEW

appview/session/context.go

···

       1
       +
       package session

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"context"

     

       5
       +
       

     

       6
       +
       	toauth "tangled.org/core/appview/oauth"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       type ctxKey struct{}

     

       10
       +
       

     

       11
       +
       func IntoContext(ctx context.Context, sess Session) context.Context {

     

       12
       +
       	return context.WithValue(ctx, ctxKey{}, &sess)

     

       13
       +
       }

     

       14
       +
       

     

       15
       +
       func FromContext(ctx context.Context) *Session {

     

       16
       +
       	sess, ok := ctx.Value(ctxKey{}).(*Session)

     

       17
       +
       	if !ok {

     

       18
       +
       		return nil

     

       19
       +
       	}

     

       20
       +
       	return sess

     

       21
       +
       }

     

       22
       +
       

     

       23
       +
       func UserFromContext(ctx context.Context) *toauth.User {

     

       24
       +
       	sess := FromContext(ctx)

     

       25
       +
       	if sess == nil {

     

       26
       +
       		return nil

     

       27
       +
       	}

     

       28
       +
       	return sess.User()

     

       29
       +
       }

NEW

appview/session/session.go

···

       1
       +
       package session

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"github.com/bluesky-social/indigo/atproto/auth/oauth"

     

       5
       +
       	toauth "tangled.org/core/appview/oauth"

     

       6
       +
       )

     

       7
       +
       

     

       8
       +
       // Session is a lightweight wrapper over indigo-oauth ClientSession

     

       9
       +
       type Session struct {

     

       10
       +
       	*oauth.ClientSession

     

       11
       +
       }

     

       12
       +
       

     

       13
       +
       func New(atSess *oauth.ClientSession) Session {

     

       14
       +
       	return Session{

     

       15
       +
       		atSess,

     

       16
       +
       	}

     

       17
       +
       }

     

       18
       +
       

     

       19
       +
       func (s *Session) User() *toauth.User {

     

       20
       +
       	return &toauth.User{

     

       21
       +
       		Did: string(s.Data.AccountDID),

     

       22
       +
       		Pds: s.Data.HostURL,

     

       23
       +
       	}

     

       24
       +
       }

NEW

appview/state/legacy_bridge.go

···

       1
       +
       package state

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"log/slog"

     

       5
       +
       

     

       6
       +
       	"tangled.org/core/appview/config"

     

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

     

       8
       +
       	"tangled.org/core/appview/indexer"

     

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

     

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

     

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

     

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

     

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

     

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

     

       15
       +
       	"tangled.org/core/idresolver"

     

       16
       +
       	"tangled.org/core/rbac"

     

       17
       +
       )

     

       18
       +
       

     

       19
       +
       // Expose exposes private fields in `State`. This is used to bridge between

     

       20
       +
       // legacy web routers and new architecture

     

       21
       +
       func (s *State) Expose() (

     

       22
       +
       	*config.Config,

     

       23
       +
       	*db.DB,

     

       24
       +
       	*rbac.Enforcer,

     

       25
       +
       	*idresolver.Resolver,

     

       26
       +
       	*indexer.Indexer,

     

       27
       +
       	*slog.Logger,

     

       28
       +
       	notify.Notifier,

     

       29
       +
       	*oauth.OAuth,

     

       30
       +
       	*pages.Pages,

     

       31
       +
       	*reporesolver.RepoResolver,

     

       32
       +
       	*validator.Validator,

     

       33
       +
       ) {

     

       34
       +
       	return s.config, s.db, s.enforcer, s.idResolver, s.indexer, s.logger, s.notifier, s.oauth, s.pages, s.repoResolver, s.validator

     

       35
       +
       }

     

       36
       +
       

     

       37
       +
       func (s *State) Middleware() *middleware.Middleware {

     

       38
       +
       	mw := middleware.New(

     

       39
       +
       		s.oauth,

     

       40
       +
       		s.db,

     

       41
       +
       		s.enforcer,

     

       42
       +
       		s.repoResolver,

     

       43
       +
       		s.idResolver,

     

       44
       +
       		s.pages,

     

       45
       +
       	)

     

       46
       +
       	return &mw

     

       47
       +
       }

NEW

appview/web/handler/oauth_client_metadata.go

···

       1
       +
       package handler

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"encoding/json"

     

       5
       +
       	"net/http"

     

       6
       +
       

     

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

     

       8
       +
       )

     

       9
       +
       

     

       10
       +
       func OauthClientMetadata(o *oauth.OAuth) http.HandlerFunc {

     

       11
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       12
       +
       		doc := o.ClientApp.Config.ClientMetadata()

     

       13
       +
       		doc.JWKSURI = &o.JwksUri

     

       14
       +
       		doc.ClientName = &o.ClientName

     

       15
       +
       		doc.ClientURI = &o.ClientUri

     

       16
       +
       

     

       17
       +
       		w.Header().Set("Content-Type", "application/json")

     

       18
       +
       		if err := json.NewEncoder(w).Encode(doc); err != nil {

     

       19
       +
       			http.Error(w, err.Error(), http.StatusInternalServerError)

     

       20
       +
       			return

     

       21
       +
       		}

     

       22
       +
       	}

     

       23
       +
       }

NEW

appview/web/handler/oauth_jwks.go

···

       1
       +
       package handler

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"encoding/json"

     

       5
       +
       	"net/http"

     

       6
       +
       

     

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

     

       8
       +
       )

     

       9
       +
       

     

       10
       +
       func OauthJwks(o *oauth.OAuth) http.HandlerFunc {

     

       11
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       12
       +
       		w.Header().Set("Content-Type", "application/json")

     

       13
       +
       		body := o.ClientApp.Config.PublicJWKS()

     

       14
       +
       		if err := json.NewEncoder(w).Encode(body); err != nil {

     

       15
       +
       			http.Error(w, err.Error(), http.StatusInternalServerError)

     

       16
       +
       			return

     

       17
       +
       		}

     

       18
       +
       	}

     

       19
       +
       }

NEW

appview/web/handler/user_repo_issues.go

···

       1
       +
       package handler

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"net/http"

     

       5
       +
       

     

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

     

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

     

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

     

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

     

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

     

       11
       +
       	isvc "tangled.org/core/appview/service/issue"

     

       12
       +
       	rsvc "tangled.org/core/appview/service/repo"

     

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

     

       14
       +
       	"tangled.org/core/appview/web/request"

     

       15
       +
       	"tangled.org/core/log"

     

       16
       +
       )

     

       17
       +
       

     

       18
       +
       func RepoIssues(is isvc.Service, rs rsvc.Service, p *pages.Pages, d *db.DB) http.HandlerFunc {

     

       19
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       20
       +
       		ctx := r.Context()

     

       21
       +
       		l := log.FromContext(ctx).With("handler", "RepoIssues")

     

       22
       +
       		repo, ok := request.RepoFromContext(ctx)

     

       23
       +
       		if !ok {

     

       24
       +
       			l.Error("malformed request")

     

       25
       +
       			p.Error503(w)

     

       26
       +
       			return

     

       27
       +
       		}

     

       28
       +
       

     

       29
       +
       		query := r.URL.Query()

     

       30
       +
       		searchOpts := models.IssueSearchOptions{

     

       31
       +
       			RepoAt:  repo.RepoAt().String(),

     

       32
       +
       			Keyword: query.Get("q"),

     

       33
       +
       			IsOpen:  query.Get("state") != "closed",

     

       34
       +
       			Page:    pagination.FromContext(ctx),

     

       35
       +
       		}

     

       36
       +
       

     

       37
       +
       		issues, err := is.GetIssues(ctx, repo, searchOpts)

     

       38
       +
       		if err != nil {

     

       39
       +
       			l.Error("failed to get issues")

     

       40
       +
       			p.Error503(w)

     

       41
       +
       			return

     

       42
       +
       		}

     

       43
       +
       

     

       44
       +
       		// render page

     

       45
       +
       		err = func() error {

     

       46
       +
       			user := session.UserFromContext(ctx)

     

       47
       +
       			repoinfo, err := rs.GetRepoInfo(ctx, repo, user)

     

       48
       +
       			if err != nil {

     

       49
       +
       				return err

     

       50
       +
       			}

     

       51
       +
       			labelDefs, err := db.GetLabelDefinitions(

     

       52
       +
       				d,

     

       53
       +
       				db.FilterIn("at_uri", repo.Labels),

     

       54
       +
       				db.FilterContains("scope", tangled.RepoIssueNSID),

     

       55
       +
       			)

     

       56
       +
       			if err != nil {

     

       57
       +
       				return err

     

       58
       +
       			}

     

       59
       +
       			defs := make(map[string]*models.LabelDefinition)

     

       60
       +
       			for _, l := range labelDefs {

     

       61
       +
       				defs[l.AtUri().String()] = &l

     

       62
       +
       			}

     

       63
       +
       			return p.RepoIssues(w, pages.RepoIssuesParams{

     

       64
       +
       				LoggedInUser: user,

     

       65
       +
       				RepoInfo:     *repoinfo,

     

       66
       +
       

     

       67
       +
       				Issues:          issues,

     

       68
       +
       				LabelDefs:       defs,

     

       69
       +
       				FilteringByOpen: searchOpts.IsOpen,

     

       70
       +
       				FilterQuery:     searchOpts.Keyword,

     

       71
       +
       				Page:            searchOpts.Page,

     

       72
       +
       			})

     

       73
       +
       		}()

     

       74
       +
       		if err != nil {

     

       75
       +
       			l.Error("failed to render", "err", err)

     

       76
       +
       			p.Error503(w)

     

       77
       +
       			return

     

       78
       +
       		}

     

       79
       +
       	}

     

       80
       +
       }

NEW

appview/web/handler/user_repo_issues_issue.go

···

       1
       +
       package handler

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"net/http"

     

       5
       +
       

     

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

     

       7
       +
       	isvc "tangled.org/core/appview/service/issue"

     

       8
       +
       	rsvc "tangled.org/core/appview/service/repo"

     

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

     

       10
       +
       	"tangled.org/core/appview/web/request"

     

       11
       +
       	"tangled.org/core/log"

     

       12
       +
       )

     

       13
       +
       

     

       14
       +
       func Issue(s isvc.Service, rs rsvc.Service, p *pages.Pages) http.HandlerFunc {

     

       15
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       16
       +
       		ctx := r.Context()

     

       17
       +
       		l := log.FromContext(ctx).With("handler", "Issue")

     

       18
       +
       		issue, ok := request.IssueFromContext(ctx)

     

       19
       +
       		if !ok {

     

       20
       +
       			l.Error("malformed request, failed to get issue")

     

       21
       +
       			p.Error503(w)

     

       22
       +
       			return

     

       23
       +
       		}

     

       24
       +
       

     

       25
       +
       		// render

     

       26
       +
       		err := func() error {

     

       27
       +
       			user := session.UserFromContext(ctx)

     

       28
       +
       			repoinfo, err := rs.GetRepoInfo(ctx, issue.Repo, user)

     

       29
       +
       			if err != nil {

     

       30
       +
       				return err

     

       31
       +
       			}

     

       32
       +
       			return p.RepoSingleIssue(w, pages.RepoSingleIssueParams{

     

       33
       +
       				LoggedInUser: user,

     

       34
       +
       				RepoInfo:     *repoinfo,

     

       35
       +
       				Issue:        issue,

     

       36
       +
       			})

     

       37
       +
       		}()

     

       38
       +
       		if err != nil {

     

       39
       +
       			l.Error("failed to render", "err", err)

     

       40
       +
       			p.Error503(w)

     

       41
       +
       			return

     

       42
       +
       		}

     

       43
       +
       	}

     

       44
       +
       }

     

       45
       +
       

     

       46
       +
       func IssueDelete(s isvc.Service, p *pages.Pages) http.HandlerFunc {

     

       47
       +
       	noticeId := "issue-actions-error"

     

       48
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       49
       +
       		ctx := r.Context()

     

       50
       +
       		l := log.FromContext(ctx).With("handler", "IssueDelete")

     

       51
       +
       		issue, ok := request.IssueFromContext(ctx)

     

       52
       +
       		if !ok {

     

       53
       +
       			l.Error("failed to get issue")

     

       54
       +
       			// TODO: 503 error with more detailed messages

     

       55
       +
       			p.Error503(w)

     

       56
       +
       			return

     

       57
       +
       		}

     

       58
       +
       		err := s.DeleteIssue(ctx, issue)

     

       59
       +
       		if err != nil {

     

       60
       +
       			p.Notice(w, noticeId, "failed to delete issue")

     

       61
       +
       			return

     

       62
       +
       		}

     

       63
       +
       		p.HxLocation(w, "/")

     

       64
       +
       	}

     

       65
       +
       }

NEW

appview/web/handler/user_repo_issues_issue_close.go

···

       1
       +
       package handler

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"net/http"

     

       5
       +
       

     

       6
       +
       	"tangled.org/core/appview/service/issue"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       func CloseIssue(s issue.Service) http.HandlerFunc {

     

       10
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       11
       +
       		panic("unimplemented")

     

       12
       +
       	}

     

       13
       +
       }

NEW

appview/web/handler/user_repo_issues_issue_edit.go

···

       1
       +
       package handler

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"errors"

     

       5
       +
       	"net/http"

     

       6
       +
       

     

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

     

       8
       +
       	isvc "tangled.org/core/appview/service/issue"

     

       9
       +
       	rsvc "tangled.org/core/appview/service/repo"

     

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

     

       11
       +
       	"tangled.org/core/appview/web/request"

     

       12
       +
       	"tangled.org/core/log"

     

       13
       +
       )

     

       14
       +
       

     

       15
       +
       func IssueEdit(is isvc.Service, rs rsvc.Service, p *pages.Pages) http.HandlerFunc {

     

       16
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       17
       +
       		ctx := r.Context()

     

       18
       +
       		l := log.FromContext(ctx).With("handler", "IssueEdit")

     

       19
       +
       		issue, ok := request.IssueFromContext(ctx)

     

       20
       +
       		if !ok {

     

       21
       +
       			l.Error("malformed request, failed to get issue")

     

       22
       +
       			p.Error503(w)

     

       23
       +
       			return

     

       24
       +
       		}

     

       25
       +
       

     

       26
       +
       		// render

     

       27
       +
       		err := func() error {

     

       28
       +
       			user := session.UserFromContext(ctx)

     

       29
       +
       			repoinfo, err := rs.GetRepoInfo(ctx, issue.Repo, user)

     

       30
       +
       			if err != nil {

     

       31
       +
       				return err

     

       32
       +
       			}

     

       33
       +
       			return p.EditIssueFragment(w, pages.EditIssueParams{

     

       34
       +
       				LoggedInUser: user,

     

       35
       +
       				RepoInfo:     *repoinfo,

     

       36
       +
       

     

       37
       +
       				Issue: issue,

     

       38
       +
       			})

     

       39
       +
       		}()

     

       40
       +
       		if err != nil {

     

       41
       +
       			l.Error("failed to render", "err", err)

     

       42
       +
       			p.Error503(w)

     

       43
       +
       			return

     

       44
       +
       		}

     

       45
       +
       	}

     

       46
       +
       }

     

       47
       +
       

     

       48
       +
       func IssueEditPost(is isvc.Service, p *pages.Pages) http.HandlerFunc {

     

       49
       +
       	noticeId := "issues"

     

       50
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       51
       +
       		ctx := r.Context()

     

       52
       +
       		l := log.FromContext(ctx).With("handler", "IssueEdit")

     

       53
       +
       		issue, ok := request.IssueFromContext(ctx)

     

       54
       +
       		if !ok {

     

       55
       +
       			l.Error("malformed request, failed to get issue")

     

       56
       +
       			p.Error503(w)

     

       57
       +
       			return

     

       58
       +
       		}

     

       59
       +
       

     

       60
       +
       		newIssue := *issue

     

       61
       +
       		newIssue.Title = r.FormValue("title")

     

       62
       +
       		newIssue.Body = r.FormValue("body")

     

       63
       +
       

     

       64
       +
       		err := is.EditIssue(ctx, &newIssue)

     

       65
       +
       		if err != nil {

     

       66
       +
       			if errors.Is(err, isvc.ErrDatabaseFail) {

     

       67
       +
       				p.Notice(w, noticeId, "Failed to edit issue.")

     

       68
       +
       			} else if errors.Is(err, isvc.ErrPDSFail) {

     

       69
       +
       				p.Notice(w, noticeId, "Failed to edit issue.")

     

       70
       +
       			} else {

     

       71
       +
       				p.Notice(w, noticeId, "Failed to edit issue.")

     

       72
       +
       			}

     

       73
       +
       		}

     

       74
       +
       

     

       75
       +
       		p.HxRefresh(w)

     

       76
       +
       	}

     

       77
       +
       }

NEW

appview/web/handler/user_repo_issues_issue_opengraph.go

···

       1
       +
       package handler

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"net/http"

     

       5
       +
       

     

       6
       +
       	"tangled.org/core/appview/service/issue"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       func IssueOpenGraph(s issue.Service) http.HandlerFunc {

     

       10
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       11
       +
       		panic("unimplemented")

     

       12
       +
       	}

     

       13
       +
       }

NEW

appview/web/handler/user_repo_issues_issue_reopen.go

···

       1
       +
       package handler

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"net/http"

     

       5
       +
       

     

       6
       +
       	"tangled.org/core/appview/service/issue"

     

       7
       +
       )

     

       8
       +
       

     

       9
       +
       func ReopenIssue(s issue.Service) http.HandlerFunc {

     

       10
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       11
       +
       		panic("unimplemented")

     

       12
       +
       	}

     

       13
       +
       }

NEW

appview/web/handler/user_repo_issues_new.go

···

       1
       +
       package handler

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"errors"

     

       5
       +
       	"fmt"

     

       6
       +
       	"net/http"

     

       7
       +
       

     

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

     

       9
       +
       	isvc "tangled.org/core/appview/service/issue"

     

       10
       +
       	rsvc "tangled.org/core/appview/service/repo"

     

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

     

       12
       +
       	"tangled.org/core/appview/web/request"

     

       13
       +
       	"tangled.org/core/log"

     

       14
       +
       )

     

       15
       +
       

     

       16
       +
       func NewIssue(rs rsvc.Service, p *pages.Pages) http.HandlerFunc {

     

       17
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       18
       +
       		ctx := r.Context()

     

       19
       +
       		l := log.FromContext(ctx).With("handler", "NewIssue")

     

       20
       +
       

     

       21
       +
       		// render

     

       22
       +
       		err := func() error {

     

       23
       +
       			user := session.UserFromContext(ctx)

     

       24
       +
       			repo, ok := request.RepoFromContext(ctx)

     

       25
       +
       			if !ok {

     

       26
       +
       				return fmt.Errorf("malformed request")

     

       27
       +
       			}

     

       28
       +
       			repoinfo, err := rs.GetRepoInfo(ctx, repo, user)

     

       29
       +
       			if err != nil {

     

       30
       +
       				return err

     

       31
       +
       			}

     

       32
       +
       			return p.RepoNewIssue(w, pages.RepoNewIssueParams{

     

       33
       +
       				LoggedInUser: user,

     

       34
       +
       				RepoInfo:     *repoinfo,

     

       35
       +
       			})

     

       36
       +
       		}()

     

       37
       +
       		if err != nil {

     

       38
       +
       			l.Error("failed to render", "err", err)

     

       39
       +
       			p.Error503(w)

     

       40
       +
       			return

     

       41
       +
       		}

     

       42
       +
       	}

     

       43
       +
       }

     

       44
       +
       

     

       45
       +
       func NewIssuePost(is isvc.Service, p *pages.Pages) http.HandlerFunc {

     

       46
       +
       	noticeId := "issues"

     

       47
       +
       	return func(w http.ResponseWriter, r *http.Request) {

     

       48
       +
       		ctx := r.Context()

     

       49
       +
       		l := log.FromContext(ctx).With("handler", "NewIssuePost")

     

       50
       +
       		repo, ok := request.RepoFromContext(ctx)

     

       51
       +
       		if !ok {

     

       52
       +
       			l.Error("malformed request, failed to get repo")

     

       53
       +
       			// TODO: 503 error with more detailed messages

     

       54
       +
       			p.Error503(w)

     

       55
       +
       			return

     

       56
       +
       		}

     

       57
       +
       		var (

     

       58
       +
       			title = r.FormValue("title")

     

       59
       +
       			body  = r.FormValue("body")

     

       60
       +
       		)

     

       61
       +
       

     

       62
       +
       		_, err := is.NewIssue(ctx, repo, title, body)

     

       63
       +
       		if err != nil {

     

       64
       +
       			if errors.Is(err, isvc.ErrDatabaseFail) {

     

       65
       +
       				p.Notice(w, noticeId, "Failed to create issue.")

     

       66
       +
       			} else if errors.Is(err, isvc.ErrPDSFail) {

     

       67
       +
       				p.Notice(w, noticeId, "Failed to create issue.")

     

       68
       +
       			} else {

     

       69
       +
       				p.Notice(w, noticeId, "Failed to create issue.")

     

       70
       +
       			}

     

       71
       +
       		}

     

       72
       +
       		p.HxLocation(w, "/")

     

       73
       +
       	}

     

       74
       +
       }

NEW

appview/web/middleware/ensuredidorhandle.go

···

       1
       +
       package middleware

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"net/http"

     

       5
       +
       

     

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

     

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

     

       8
       +
       	"tangled.org/core/appview/state/userutil"

     

       9
       +
       )

     

       10
       +
       

     

       11
       +
       // EnsureDidOrHandle ensures the "user" url param is valid did/handle format.

     

       12
       +
       // If not, respond with 404

     

       13
       +
       func EnsureDidOrHandle(p *pages.Pages) middlewareFunc {

     

       14
       +
       	return func(next http.Handler) http.Handler {

     

       15
       +
       		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       16
       +
       			user := chi.URLParam(r, "user")

     

       17
       +
       

     

       18
       +
       			// if using a DID or handle, just continue as per usual

     

       19
       +
       			if userutil.IsDid(user) || userutil.IsHandle(user) {

     

       20
       +
       				next.ServeHTTP(w, r)

     

       21
       +
       				return

     

       22
       +
       			}

     

       23
       +
       

     

       24
       +
       			// TODO: run Normalize middleware from here

     

       25
       +
       

     

       26
       +
       			p.Error404(w)

     

       27
       +
       			return

     

       28
       +
       		})

     

       29
       +
       	}

     

       30
       +
       }

NEW

appview/web/middleware/normalize.go

···

       1
       +
       package middleware

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"net/http"

     

       5
       +
       	"strings"

     

       6
       +
       

     

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

     

       8
       +
       	"tangled.org/core/appview/state/userutil"

     

       9
       +
       )

     

       10
       +
       

     

       11
       +
       func Normalize() middlewareFunc {

     

       12
       +
       	return func(next http.Handler) http.Handler {

     

       13
       +
       		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

     

       14
       +
       			pat := chi.URLParam(r, "*")

     

       15
       +
       			pathParts := strings.SplitN(pat, "/", 2)

     

       16
       +
       			if len(pathParts) == 0 {

     

       17
       +
       				next.ServeHTTP(w, r)

     

       18
       +
       				return

     

       19
       +
       			}

     

       20
       +
       

     

       21
       +
       			firstPart := pathParts[0]

     

       22
       +
       

     

       23
       +
       			// if using a flattened DID (like you would in go modules), unflatten

     

       24
       +
       			if userutil.IsFlattenedDid(firstPart) {

     

       25
       +
       				unflattenedDid := userutil.UnflattenDid(firstPart)

     

       26
       +
       				redirectPath := strings.Join(append([]string{unflattenedDid}, pathParts[1:]...), "/")

     

       27
       +
       

     

       28
       +
       				redirectURL := *r.URL

     

       29
       +
       				redirectURL.Path = "/" + redirectPath

     

       30
       +
       

     

       31
       +
       				http.Redirect(w, r, redirectURL.String(), http.StatusFound)

     

       32
       +
       				return

     

       33
       +
       			}

     

       34
       +
       

     

       35
       +
       			// if using a handle with @, rewrite to work without @

     

       36
       +
       			if normalized := strings.TrimPrefix(firstPart, "@"); userutil.IsHandle(normalized) {

     

       37
       +
       				redirectPath := strings.Join(append([]string{normalized}, pathParts[1:]...), "/")

     

       38
       +
       

     

       39
       +
       				redirectURL := *r.URL

     

       40
       +
       				redirectURL.Path = "/" + redirectPath

     

       41
       +
       

     

       42
       +
       				http.Redirect(w, r, redirectURL.String(), http.StatusFound)

     

       43
       +
       				return

     

       44
       +
       			}

     

       45
       +
       

     

       46
       +
       			next.ServeHTTP(w, r)

     

       47
       +
       			return

     

       48
       +
       		})

     

       49
       +
       	}

     

       50
       +
       }

NEW

appview/web/request/context.go

···

       1
       +
       package request

     

       2
       +
       

     

       3
       +
       import (

     

       4
       +
       	"context"

     

       5
       +
       

     

       6
       +
       	"github.com/bluesky-social/indigo/atproto/identity"

     

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

     

       8
       +
       )

     

       9
       +
       

     

       10
       +
       type ctxKeyOwner struct{}

     

       11
       +
       type ctxKeyRepo struct{}

     

       12
       +
       type ctxKeyIssue struct{}

     

       13
       +
       

     

       14
       +
       func WithOwner(ctx context.Context, owner *identity.Identity) context.Context {

     

       15
       +
       	return context.WithValue(ctx, ctxKeyOwner{}, owner)

     

       16
       +
       }

     

       17
       +
       

     

       18
       +
       func OwnerFromContext(ctx context.Context) (*identity.Identity, bool) {

     

       19
       +
       	owner, ok := ctx.Value(ctxKeyOwner{}).(*identity.Identity)

     

       20
       +
       	return owner, ok

     

       21
       +
       }

     

       22
       +
       

     

       23
       +
       func WithRepo(ctx context.Context, repo *models.Repo) context.Context {

     

       24
       +
       	return context.WithValue(ctx, ctxKeyRepo{}, repo)

     

       25
       +
       }

     

       26
       +
       

     

       27
       +
       func RepoFromContext(ctx context.Context) (*models.Repo, bool) {

     

       28
       +
       	repo, ok := ctx.Value(ctxKeyRepo{}).(*models.Repo)

     

       29
       +
       	return repo, ok

     

       30
       +
       }

     

       31
       +
       

     

       32
       +
       func WithIssue(ctx context.Context, issue *models.Issue) context.Context {

     

       33
       +
       	return context.WithValue(ctx, ctxKeyIssue{}, issue)

     

       34
       +
       }

     

       35
       +
       

     

       36
       +
       func IssueFromContext(ctx context.Context) (*models.Issue, bool) {

     

       37
       +
       	issue, ok := ctx.Value(ctxKeyIssue{}).(*models.Issue)

     

       38
       +
       	return issue, ok

     

       39
       +
       }

NEW

cmd/appview/main.go

···

       7
        
       

     

       8
        
       	"tangled.org/core/appview/config"

     

       9
        
       	"tangled.org/core/appview/state"

     

       0
        
       
     

       10
        
       	tlog "tangled.org/core/log"

     

       11
        
       )

     

       12
        
       

     
···

       35
        
       

     

       36
        
       	logger.Info("starting server", "address", c.Core.ListenAddr)

     

       37
        
       

     

       38
       -
       	if err := http.ListenAndServe(c.Core.ListenAddr, state.Router()); err != nil {

     

       39
        
       		logger.Error("failed to start appview", "err", err)

     

       40
        
       	}

     

       41
        
       }

···

       7
        
       

     

       8
        
       	"tangled.org/core/appview/config"

     

       9
        
       	"tangled.org/core/appview/state"

     

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

     

       11
        
       	tlog "tangled.org/core/log"

     

       12
        
       )

     

       13
        
       

     
···

       36
        
       

     

       37
        
       	logger.Info("starting server", "address", c.Core.ListenAddr)

     

       38
        
       

     

       39
       +
       	if err := http.ListenAndServe(c.Core.ListenAddr, web.RouterFromState(state)); err != nil {

     

       40
        
       		logger.Error("failed to start appview", "err", err)

     

       41
        
       	}

     

       42
        
       }