commit 92962a5110bbc9eb1cb008270131cb5087fa4f0b · julien.rbrt.fr/tangled-core

+21 -10

appview/issues/router.go

···

       12
       12
        
       

     

       13
       13
        
       	r.Route("/", func(r chi.Router) {

     

       14
       14
        
       		r.With(middleware.Paginate).Get("/", i.RepoIssues)

     

       15
       15
       -
       		r.Get("/{issue}", i.RepoSingleIssue)

     

       15
       15
       +
       

     

       16
       16
       +
       		r.Route("/{issue}", func(r chi.Router) {

     

       17
       17
       +
       			r.Use(mw.ResolveIssue())

     

       18
       18
       +
       			r.Get("/", i.RepoSingleIssue)

     

       19
       19
       +
       

     

       20
       20
       +
       			// authenticated routes

     

       21
       21
       +
       			r.Group(func(r chi.Router) {

     

       22
       22
       +
       				r.Use(middleware.AuthMiddleware(i.oauth))

     

       23
       23
       +
       				r.Post("/comment", i.NewIssueComment)

     

       24
       24
       +
       				r.Route("/comment/{commentId}/", func(r chi.Router) {

     

       25
       25
       +
       					r.Get("/", i.IssueComment)

     

       26
       26
       +
       					r.Delete("/", i.DeleteIssueComment)

     

       27
       27
       +
       					r.Get("/edit", i.EditIssueComment)

     

       28
       28
       +
       					r.Post("/edit", i.EditIssueComment)

     

       29
       29
       +
       					r.Get("/reply", i.ReplyIssueComment)

     

       30
       30
       +
       					r.Get("/replyPlaceholder", i.ReplyIssueCommentPlaceholder)

     

       31
       31
       +
       				})

     

       32
       32
       +
       				r.Post("/close", i.CloseIssue)

     

       33
       33
       +
       				r.Post("/reopen", i.ReopenIssue)

     

       34
       34
       +
       			})

     

       35
       35
       +
       		})

     

       16
       36
        
       

     

       17
       37
        
       		r.Group(func(r chi.Router) {

     

       18
       38
        
       			r.Use(middleware.AuthMiddleware(i.oauth))

     

       19
       39
        
       			r.Get("/new", i.NewIssue)

     

       20
       40
        
       			r.Post("/new", i.NewIssue)

     

       21
       21
       -
       			r.Post("/{issue}/comment", i.NewIssueComment)

     

       22
       22
       -
       			r.Route("/{issue}/comment/{comment_id}/", func(r chi.Router) {

     

       23
       23
       -
       				r.Get("/", i.IssueComment)

     

       24
       24
       -
       				r.Delete("/", i.DeleteIssueComment)

     

       25
       25
       -
       				r.Get("/edit", i.EditIssueComment)

     

       26
       26
       -
       				r.Post("/edit", i.EditIssueComment)

     

       27
       27
       -
       			})

     

       28
       28
       -
       			r.Post("/{issue}/close", i.CloseIssue)

     

       29
       29
       -
       			r.Post("/{issue}/reopen", i.ReopenIssue)

     

       30
       41
        
       		})

     

       31
       42
        
       	})

     

       32
       43

+40

appview/middleware/middleware.go

···

       275
       275
        
       	}

     

       276
       276
        
       }

     

       277
       277
        
       

     

       278
       278
       +
       // middleware that is tacked on top of /{user}/{repo}/issues/{issue}

     

       279
       279
       +
       func (mw Middleware) ResolveIssue() middlewareFunc {

     

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

     

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

     

       282
       282
       +
       			f, err := mw.repoResolver.Resolve(r)

     

       283
       283
       +
       			if err != nil {

     

       284
       284
       +
       				log.Println("failed to fully resolve repo", err)

     

       285
       285
       +
       				mw.pages.ErrorKnot404(w)

     

       286
       286
       +
       				return

     

       287
       287
       +
       			}

     

       288
       288
       +
       

     

       289
       289
       +
       			issueIdStr := chi.URLParam(r, "issue")

     

       290
       290
       +
       			issueId, err := strconv.Atoi(issueIdStr)

     

       291
       291
       +
       			if err != nil {

     

       292
       292
       +
       				log.Println("failed to fully resolve issue ID", err)

     

       293
       293
       +
       				mw.pages.ErrorKnot404(w)

     

       294
       294
       +
       				return

     

       295
       295
       +
       			}

     

       296
       296
       +
       

     

       297
       297
       +
       			issues, err := db.GetIssues(

     

       298
       298
       +
       				mw.db,

     

       299
       299
       +
       				db.FilterEq("repo_at", f.RepoAt()),

     

       300
       300
       +
       				db.FilterEq("issue_id", issueId),

     

       301
       301
       +
       			)

     

       302
       302
       +
       			if err != nil {

     

       303
       303
       +
       				log.Println("failed to get issues", "err", err)

     

       304
       304
       +
       				return

     

       305
       305
       +
       			}

     

       306
       306
       +
       			if len(issues) != 1 {

     

       307
       307
       +
       				log.Println("got incorrect number of issues", "len(issuse)", len(issues))

     

       308
       308
       +
       				return

     

       309
       309
       +
       			}

     

       310
       310
       +
       			issue := issues[0]

     

       311
       311
       +
       

     

       312
       312
       +
       			ctx := context.WithValue(r.Context(), "issue", &issue)

     

       313
       313
       +
       			next.ServeHTTP(w, r.WithContext(ctx))

     

       314
       314
       +
       		})

     

       315
       315
       +
       	}

     

       316
       316
       +
       }

     

       317
       317
       +
       

     

       278
       318
        
       // this should serve the go-import meta tag even if the path is technically

     

       279
       319
        
       // a 404 like tangled.sh/oppi.li/go-git/v5

     

       280
       320
        
       func (mw Middleware) GoImport() middlewareFunc {

+1 -1

appview/posthog/notifier.go

···

       58
       58
        
       

     

       59
       59
        
       func (n *posthogNotifier) NewIssue(ctx context.Context, issue *db.Issue) {

     

       60
       60
        
       	err := n.client.Enqueue(posthog.Capture{

     

       61
       61
       -
       		DistinctId: issue.OwnerDid,

     

       61
       61
       +
       		DistinctId: issue.Did,

     

       62
       62
        
       		Event:      "new_issue",

     

       63
       63
        
       		Properties: posthog.Properties{

     

       64
       64
        
       			"repo_at":  issue.RepoAt.String(),

+1 -1

appview/repo/feed.go

···

       104
       104
        
       }

     

       105
       105
        
       

     

       106
       106
        
       func (rp *Repo) createIssueItem(ctx context.Context, issue db.Issue, f *reporesolver.ResolvedRepo) (*feeds.Item, error) {

     

       107
       107
       -
       	owner, err := rp.idResolver.ResolveIdent(ctx, issue.OwnerDid)

     

       107
       107
       +
       	owner, err := rp.idResolver.ResolveIdent(ctx, issue.Did)

     

       108
       108
        
       	if err != nil {

     

       109
       109
        
       		return nil, err

     

       110
       110
        
       	}