patch of appview/pages: show trending repos in the timeline · round #2 · pull #515 · tangled.org/core

appview/db/db.go

···

       470
       470
        
       			id integer primary key autoincrement,

     

       471
       471
        
       			name text unique

     

       472
       472
        
       		);

     

       473
       473
       +
       

     

       474
       474
       +
       		-- indexes for better star query performance

     

       475
       475
       +
       		create index if not exists idx_stars_created on stars(created);

     

       476
       476
       +
       		create index if not exists idx_stars_repo_at_created on stars(repo_at, created);

     

       473
       477
        
       	`)

     

       474
       478
        
       	if err != nil {

     

       475
       479
        
       		return nil, err

+72 -3

appview/db/star.go

···

       47
       47
        
       // Get a star record

     

       48
       48
        
       func GetStar(e Execer, starredByDid string, repoAt syntax.ATURI) (*Star, error) {

     

       49
       49
        
       	query := `

     

       50
       50
       -
       	select starred_by_did, repo_at, created, rkey 

     

       50
       50
       +
       	select starred_by_did, repo_at, created, rkey

     

       51
       51
        
       	from stars

     

       52
       52
        
       	where starred_by_did = ? and repo_at = ?`

     

       53
       53
        
       	row := e.QueryRow(query, starredByDid, repoAt)

     
···

       119
       119
        
       	}

     

       120
       120
        
       

     

       121
       121
        
       	repoQuery := fmt.Sprintf(

     

       122
       122
       -
       		`select starred_by_did, repo_at, created, rkey 

     

       122
       122
       +
       		`select starred_by_did, repo_at, created, rkey

     

       123
       123
        
       		from stars

     

       124
       124
        
       		%s

     

       125
       125
        
       		order by created desc

     
···

       187
       187
        
       	var stars []Star

     

       188
       188
        
       

     

       189
       189
        
       	rows, err := e.Query(`

     

       190
       190
       -
       		select 

     

       190
       190
       +
       		select

     

       191
       191
        
       			s.starred_by_did,

     

       192
       192
        
       			s.repo_at,

     

       193
       193
        
       			s.rkey,

     
···

       244
       244
        
       

     

       245
       245
        
       	return stars, nil

     

       246
       246
        
       }

     

       247
       247
       +
       

     

       248
       248
       +
       // GetTopStarredReposLastWeek returns the top 8 most starred repositories from the last week

     

       249
       249
       +
       func GetTopStarredReposLastWeek(e Execer) ([]Repo, error) {

     

       250
       250
       +
       	// first, get the top repo URIs by star count from the last week

     

       251
       251
       +
       	query := `

     

       252
       252
       +
       		with recent_starred_repos as (

     

       253
       253
       +
       			select distinct repo_at

     

       254
       254
       +
       			from stars

     

       255
       255
       +
       			where created >= datetime('now', '-7 days')

     

       256
       256
       +
       		),

     

       257
       257
       +
       		repo_star_counts as (

     

       258
       258
       +
       			select

     

       259
       259
       +
       				s.repo_at,

     

       260
       260
       +
       				count(*) as star_count

     

       261
       261
       +
       			from stars s

     

       262
       262
       +
       			join recent_starred_repos rsr on s.repo_at = rsr.repo_at

     

       263
       263
       +
       			group by s.repo_at

     

       264
       264
       +
       		)

     

       265
       265
       +
       		select rsc.repo_at

     

       266
       266
       +
       		from repo_star_counts rsc

     

       267
       267
       +
       		order by rsc.star_count desc

     

       268
       268
       +
       		limit 8

     

       269
       269
       +
       	`

     

       270
       270
       +
       

     

       271
       271
       +
       	rows, err := e.Query(query)

     

       272
       272
       +
       	if err != nil {

     

       273
       273
       +
       		return nil, err

     

       274
       274
       +
       	}

     

       275
       275
       +
       	defer rows.Close()

     

       276
       276
       +
       

     

       277
       277
       +
       	var repoUris []string

     

       278
       278
       +
       	for rows.Next() {

     

       279
       279
       +
       		var repoUri string

     

       280
       280
       +
       		err := rows.Scan(&repoUri)

     

       281
       281
       +
       		if err != nil {

     

       282
       282
       +
       			return nil, err

     

       283
       283
       +
       		}

     

       284
       284
       +
       		repoUris = append(repoUris, repoUri)

     

       285
       285
       +
       	}

     

       286
       286
       +
       

     

       287
       287
       +
       	if err := rows.Err(); err != nil {

     

       288
       288
       +
       		return nil, err

     

       289
       289
       +
       	}

     

       290
       290
       +
       

     

       291
       291
       +
       	if len(repoUris) == 0 {

     

       292
       292
       +
       		return []Repo{}, nil

     

       293
       293
       +
       	}

     

       294
       294
       +
       

     

       295
       295
       +
       	// get full repo data

     

       296
       296
       +
       	repos, err := GetRepos(e, 0, FilterIn("at_uri", repoUris))

     

       297
       297
       +
       	if err != nil {

     

       298
       298
       +
       		return nil, err

     

       299
       299
       +
       	}

     

       300
       300
       +
       

     

       301
       301
       +
       	// sort repos by the original trending order

     

       302
       302
       +
       	repoMap := make(map[string]Repo)

     

       303
       303
       +
       	for _, repo := range repos {

     

       304
       304
       +
       		repoMap[repo.RepoAt().String()] = repo

     

       305
       305
       +
       	}

     

       306
       306
       +
       

     

       307
       307
       +
       	orderedRepos := make([]Repo, 0, len(repoUris))

     

       308
       308
       +
       	for _, uri := range repoUris {

     

       309
       309
       +
       		if repo, exists := repoMap[uri]; exists {

     

       310
       310
       +
       			orderedRepos = append(orderedRepos, repo)

     

       311
       311
       +
       		}

     

       312
       312
       +
       	}

     

       313
       313
       +
       

     

       314
       314
       +
       	return orderedRepos, nil

     

       315
       315
       +
       }

+10 -1

appview/pages/pages.go

···

       302
       302
        
       }

     

       303
       303
        
       

     

       304
       304
        
       func (p *Pages) Timeline(w io.Writer, params TimelineParams) error {

     

       305
       305
       -
       	return p.execute("timeline", w, params)

     

       305
       305
       +
       	return p.execute("timeline/timeline", w, params)

     

       306
       306
       +
       }

     

       307
       307
       +
       

     

       308
       308
       +
       type TopStarredReposLastWeekParams struct {

     

       309
       309
       +
       	LoggedInUser *oauth.User

     

       310
       310
       +
       	Repos        []db.Repo

     

       311
       311
       +
       }

     

       312
       312
       +
       

     

       313
       313
       +
       func (p *Pages) TopStarredReposLastWeek(w io.Writer, params TopStarredReposLastWeekParams) error {

     

       314
       314
       +
       	return p.executePlain("timeline/fragments/topStarredRepos", w, params)

     

       306
       315
        
       }

     

       307
       316
        
       

     

       308
       317
        
       type SettingsParams struct {

+25

appview/pages/templates/timeline/fragments/topStarredRepos.html

···

       1
       1
       +
       {{ define "timeline/fragments/topStarredRepos" }}

     

       2
       2
       +
       <div class="w-full md:mx-0">

     

       3
       3
       +
           <div class="p-6">

     

       4
       4
       +
               <h3 class="font-bold text-xl text-gray-900 dark:text-white flex items-center gap-2 mb-3">

     

       5
       5
       +
                   Trending

     

       6
       6
       +
                   {{ i "trending-up" "size-4 flex-shrink-0" }}

     

       7
       7
       +
               </h3>

     

       8
       8
       +
           </div>

     

       9
       9
       +
           <div class="flex gap-3 overflow-x-auto pb-4 px-4 scrollbar-hide">

     

       10
       10
       +
               {{ range $index, $repo := .Repos }}

     

       11
       11
       +
                   <div class="flex-none w-72 relative h-full">

     

       12
       12
       +
                       <div class="relative h-full items-stretch border border-gray-200 dark:border-gray-700 rounded-sm">

     

       13
       13
       +
                           {{ template "user/fragments/repoCard" (list $ $repo true) }}

     

       14
       14
       +
                       </div>

     

       15
       15
       +
                   </div>

     

       16
       16
       +
               {{ else }}

     

       17
       17
       +
                   <div class="py-8 px-6 bg-white dark:bg-gray-800 border border-gray-200 dark:border-gray-700 rounded-sm">

     

       18
       18
       +
                       <div class="text-sm text-gray-500 dark:text-gray-400 text-center">

     

       19
       19
       +
                           No trending repositories this week

     

       20
       20
       +
                       </div>

     

       21
       21
       +
                   </div>

     

       22
       22
       +
               {{ end }}

     

       23
       23
       +
           </div>

     

       24
       24
       +
       </div>

     

       25
       25
       +
       {{ end }}

+28 -4

appview/pages/templates/timeline.html appview/pages/templates/timeline/timeline.html

···

       4
       4
        
           <meta property="og:title" content="timeline · tangled" />

     

       5
       5
        
           <meta property="og:type" content="object" />

     

       6
       6
        
           <meta property="og:url" content="https://tangled.sh" />

     

       7
       7
       -
           <meta property="og:description" content="see what's tangling" />

     

       7
       7
       +
           <meta property="og:description" content="tightly-knit social coding" />

     

       8
       8
        
       {{ end }}

     

       9
       9
        
       

     

       10
       10
       -
       {{ define "topbar" }}

     

       11
       11
       -
         {{ template "layouts/topbar" $ }}

     

       12
       12
       -
       {{ end }}

     

       10
       10
       +
       

     

       11
       11
       +
       

     

       13
       12
        
       

     

       14
       13
        
       {{ define "content" }}

     

       15
       14
        
           {{ with .LoggedInUser }}

     

       15
       15
       +
               {{ block "trending" . }}{{ end }}

     

       16
       16
        
               {{ block "timeline" $ }}{{ end }}

     

       17
       17
        
           {{ else }}

     

       18
       18
        
               {{ block "hero" $ }}{{ end }}

     

       19
       19
       +
               {{ block "trending" . }}{{ end }}

     

       19
       20
        
               {{ block "timeline" $ }}{{ end }}

     

       20
       21
        
           {{ end }}

     

       21
       22
        
       {{ end }}

     

       22
       23
        
       

     

       24
       24
       +
       {{ define "trending" }}

     

       25
       25
       +
       

     

       26
       26
       +
           <div

     

       27
       27
       +
               hx-get="/timeline/trending"

     

       28
       28
       +
               hx-trigger="load"

     

       29
       29
       +
               hx-indicator="#starred-loading"

     

       30
       30
       +
           >

     

       31
       31
       +
               <!-- Loading spinner -->

     

       32
       32
       +
               <div id="starred-loading" class="htmx-indicator">

     

       33
       33
       +
                   <div class="p-6">

     

       34
       34
       +
                       <h3 class="font-bold text-xl  text-gray-900 dark:text-white flex items-center gap-2 mb-3">

     

       35
       35
       +
                           Trending

     

       36
       36
       +
                           {{ i "trending-up" "size-4 flex-shrink-0" }}

     

       37
       37
       +
                       </h3>

     

       38
       38
       +
                   </div>

     

       39
       39
       +
                   <div class="flex items-center justify-center py-8">

     

       40
       40
       +
                       <div class="animate-spin rounded-full h-6 w-6 border-b-2 border-gray-900 dark:border-white"></div>

     

       41
       41
       +
                       <span class="ml-2 text-sm text-gray-500 dark:text-gray-400">Loading...</span>

     

       42
       42
       +
                   </div>

     

       43
       43
       +
               </div>

     

       44
       44
       +
           </div>

     

       45
       45
       +
       {{ end }}

     

       46
       46
       +
       

     

       23
       47
        
       {{ define "hero" }}

     

       24
       48
        
           <div class="flex flex-col text-black dark:text-white p-6 gap-6 max-w-xl">

     

       25
       49
        
               <div class="font-bold text-4xl">tightly-knit<br>social coding.</div>

+2 -2

appview/pages/templates/user/fragments/repoCard.html

···

       14
       14
        
       

     

       15
       15
        
               {{ $repoOwner := resolve .Did }}

     

       16
       16
        
               {{- if $fullName -}}

     

       17
       17
       -
                 <a href="/{{ $repoOwner }}/{{ .Name }}">{{ $repoOwner }}/{{ .Name }}</a>

     

       17
       17
       +
                 <a href="/{{ $repoOwner }}/{{ .Name }}" class="truncate">{{ $repoOwner }}/{{ .Name }}</a>

     

       18
       18
        
               {{- else -}}

     

       19
       19
       -
                 <a href="/{{ $repoOwner }}/{{ .Name }}">{{ .Name }}</a>

     

       19
       19
       +
                 <a href="/{{ $repoOwner }}/{{ .Name }}" class="truncate">{{ .Name }}</a>

     

       20
       20
        
               {{- end -}}

     

       21
       21
        
             </div>

     

       22
       22
        
             {{ with .Description }}

appview/state/router.go

···

       109
       109
        
       	r.Handle("/static/*", s.pages.Static())

     

       110
       110
        
       

     

       111
       111
        
       	r.Get("/", s.Timeline)

     

       112
       112
       +
       	r.Get("/timeline/trending", s.TopStarredReposLastWeek)

     

       112
       113
        
       

     

       113
       114
        
       	r.Route("/repo", func(r chi.Router) {

     

       114
       115
        
       		r.Route("/new", func(r chi.Router) {

+13

appview/state/state.go

···

       199
       199
        
       	})

     

       200
       200
        
       }

     

       201
       201
        
       

     

       202
       202
       +
       func (s *State) TopStarredReposLastWeek(w http.ResponseWriter, r *http.Request) {

     

       203
       203
       +
       	repos, err := db.GetTopStarredReposLastWeek(s.db)

     

       204
       204
       +
       	if err != nil {

     

       205
       205
       +
       		log.Println(err)

     

       206
       206
       +
       		s.pages.Notice(w, "topstarredrepos", "Unable to load.")

     

       207
       207
       +
       		return

     

       208
       208
       +
       	}

     

       209
       209
       +
       

     

       210
       210
       +
       	s.pages.TopStarredReposLastWeek(w, pages.TopStarredReposLastWeekParams{

     

       211
       211
       +
       		Repos: repos,

     

       212
       212
       +
       	})

     

       213
       213
       +
       }

     

       214
       214
       +
       

     

       202
       215
        
       func (s *State) Keys(w http.ResponseWriter, r *http.Request) {

     

       203
       216
        
       	user := chi.URLParam(r, "user")

     

       204
       217
        
       	user = strings.TrimPrefix(user, "@")