commit 82f4285274e33ca33f062935fc1ca8661f9936ac · veryroundbird.house/core

+1 -1

appview/db/follow.go

···

       13
       13
        
       }

     

       14
       14
        
       

     

       15
       15
        
       func (d *DB) AddFollow(userDid, subjectDid, rkey string) error {

     

       16
       16
       -
       	query := `insert into follows (user_did, subject_did, rkey) values (?, ?, ?)`

     

       16
       16
       +
       	query := `insert or ignore into follows (user_did, subject_did, rkey) values (?, ?, ?)`

     

       17
       17
        
       	_, err := d.db.Exec(query, userDid, subjectDid, rkey)

     

       18
       18
        
       	return err

     

       19
       19
        
       }

+1 -1

appview/db/pubkeys.go

···

       6
       6
        
       )

     

       7
       7
        
       

     

       8
       8
        
       func (d *DB) AddPublicKey(did, name, key string) error {

     

       9
       9
       -
       	query := `insert into public_keys (did, name, key) values (?, ?, ?)`

     

       9
       9
       +
       	query := `insert or ignore into public_keys (did, name, key) values (?, ?, ?)`

     

       10
       10
        
       	_, err := d.db.Exec(query, did, name, key)

     

       11
       11
        
       	return err

     

       12
       12
        
       }

+7 -1

appview/pages/pages.go

···

       326
       326
        
       	return p.executeRepo("repo/blob", w, params)

     

       327
       327
        
       }

     

       328
       328
        
       

     

       329
       329
       +
       type Collaborator struct {

     

       330
       330
       +
       	Did    string

     

       331
       331
       +
       	Handle string

     

       332
       332
       +
       	Role   string

     

       333
       333
       +
       }

     

       334
       334
       +
       

     

       329
       335
        
       type RepoSettingsParams struct {

     

       330
       336
        
       	LoggedInUser                *auth.User

     

       331
       337
        
       	RepoInfo                    RepoInfo

     

       332
       332
       -
       	Collaborators               [][]string

     

       338
       338
       +
       	Collaborators               []Collaborator

     

       333
       339
        
       	Active                      string

     

       334
       340
        
       	IsCollaboratorInviteAllowed bool

     

       335
       341
        
       }

+16 -12

appview/pages/templates/repo/settings.html

···

       1
       1
        
       {{ define "repoContent" }}

     

       2
       2
       -
           <h3>settings</h3>

     

       3
       3
       -
           <em>collaborators</em>

     

       4
       4
       -
           <ol>

     

       5
       5
       -
               {{ range .Collaborators }}

     

       6
       6
       -
                   <li>

     

       7
       7
       -
                       {{ index . 0 }} -

     

       8
       8
       -
                       {{ index . 3 }}

     

       9
       9
       -
                   </li>

     

       10
       10
       -
               {{ else }}

     

       11
       11
       -
                   <p>no members</p>

     

       12
       12
       -
               {{ end }}

     

       13
       13
       -
           </ol>

     

       2
       2
       +
           <header class="font-bold text-sm mb-4">COLLABORATORS</header>

     

       3
       3
       +
       

     

       4
       4
       +
           <div id="collaborator-list" class="flex flex-col gap-2 mb-2">

     

       5
       5
       +
             {{ range .Collaborators }}

     

       6
       6
       +
             <div id="collaborator" class="mb-2">

     

       7
       7
       +
               <a href="/{{ didOrHandle .Did .Handle }}" class="no-underline hover:underline text-black">

     

       8
       8
       +
                 {{ didOrHandle .Did .Handle }}

     

       9
       9
       +
               </a>

     

       10
       10
       +
               <div>

     

       11
       11
       +
                 <span class="text-sm text-gray-500">

     

       12
       12
       +
                   {{ .Role }}

     

       13
       13
       +
                 </span>

     

       14
       14
       +
               </div>

     

       15
       15
       +
             </div>

     

       16
       16
       +
             {{ end }}

     

       17
       17
       +
           </div>

     

       14
       18
        
       

     

       15
       19
        
           {{ if .IsCollaboratorInviteAllowed }}

     

       16
       20
        
               <h3>add collaborator</h3>

+41 -2

appview/state/repo.go

···

       1
       1
        
       package state

     

       2
       2
        
       

     

       3
       3
        
       import (

     

       4
       4
       +
       	"context"

     

       4
       5
        
       	"encoding/json"

     

       5
       6
        
       	"fmt"

     

       6
       7
        
       	"io"

     
···

       407
       408
        
       	case http.MethodGet:

     

       408
       409
        
       		// for now, this is just pubkeys

     

       409
       410
        
       		user := s.auth.GetUser(r)

     

       410
       410
       -
       		repoCollaborators, err := s.enforcer.E.GetImplicitUsersForResourceByDomain(f.OwnerSlashRepo(), f.Knot)

     

       411
       411
       +
       		repoCollaborators, err := f.Collaborators(r.Context(), s)

     

       411
       412
        
       		if err != nil {

     

       412
       413
        
       			log.Println("failed to get collaborators", err)

     

       413
       414
        
       		}

     

       414
       414
       -
       		log.Println(repoCollaborators)

     

       415
       415
        
       

     

       416
       416
        
       		isCollaboratorInviteAllowed := false

     

       417
       417
        
       		if user != nil {

     
···

       452
       452
        
       func (f *FullyResolvedRepo) OwnerSlashRepo() string {

     

       453
       453
        
       	p, _ := securejoin.SecureJoin(f.OwnerDid(), f.RepoName)

     

       454
       454
        
       	return p

     

       455
       455
       +
       }

     

       456
       456
       +
       

     

       457
       457
       +
       func (f *FullyResolvedRepo) Collaborators(ctx context.Context, s *State) ([]pages.Collaborator, error) {

     

       458
       458
       +
       	repoCollaborators, err := s.enforcer.E.GetImplicitUsersForResourceByDomain(f.OwnerSlashRepo(), f.Knot)

     

       459
       459
       +
       	if err != nil {

     

       460
       460
       +
       		return nil, err

     

       461
       461
       +
       	}

     

       462
       462
       +
       

     

       463
       463
       +
       	var collaborators []pages.Collaborator

     

       464
       464
       +
       	for _, item := range repoCollaborators {

     

       465
       465
       +
       		// currently only two roles: owner and member

     

       466
       466
       +
       		var role string

     

       467
       467
       +
       		if item[3] == "repo:owner" {

     

       468
       468
       +
       			role = "owner"

     

       469
       469
       +
       		} else if item[3] == "repo:collaborator" {

     

       470
       470
       +
       			role = "collaborator"

     

       471
       471
       +
       		} else {

     

       472
       472
       +
       			continue

     

       473
       473
       +
       		}

     

       474
       474
       +
       

     

       475
       475
       +
       		did := item[0]

     

       476
       476
       +
       

     

       477
       477
       +
       		var handle string

     

       478
       478
       +
       		id, err := s.resolver.ResolveIdent(ctx, did)

     

       479
       479
       +
       		if err != nil {

     

       480
       480
       +
       			handle = ""

     

       481
       481
       +
       		} else {

     

       482
       482
       +
       			handle = string(id.Handle)

     

       483
       483
       +
       		}

     

       484
       484
       +
       

     

       485
       485
       +
       		c := pages.Collaborator{

     

       486
       486
       +
       			Did:    did,

     

       487
       487
       +
       			Handle: handle,

     

       488
       488
       +
       			Role:   role,

     

       489
       489
       +
       		}

     

       490
       490
       +
       		collaborators = append(collaborators, c)

     

       491
       491
       +
       	}

     

       492
       492
       +
       

     

       493
       493
       +
       	return collaborators, nil

     

       455
       494
        
       }

     

       456
       495
        
       

     

       457
       496
        
       func fullyResolvedRepo(r *http.Request) (*FullyResolvedRepo, error) {

+1

rbac/rbac.go

···

       119
       119
        
       	}

     

       120
       120
        
       

     

       121
       121
        
       	_, err := e.E.AddPolicies([][]string{

     

       122
       122
       +
       		{collaborator, domain, repo, "repo:collaborator"},

     

       122
       123
        
       		{collaborator, domain, repo, "repo:settings"},

     

       123
       124
        
       		{collaborator, domain, repo, "repo:push"},

     

       124
       125
        
       	})