commit d759587b58edcebd97de7569c4d841b18b8152b9 · julien.rbrt.fr/tangled-core

+31

appview/knotclient/signer.go

···

       106
       106
        
       	return s.client.Do(req)

     

       107
       107
        
       }

     

       108
       108
        
       

     

       109
       109
       +
       func (s *SignedClient) RepoLanguages(ownerDid, source, name, branch string) (*types.RepoLanguageResponse, error) {

     

       110
       110
       +
       	const (

     

       111
       111
       +
       		Method = "GET"

     

       112
       112
       +
       	)

     

       113
       113
       +
       	endpoint := fmt.Sprintf("/repo/languages/%s", url.PathEscape(branch))

     

       114
       114
       +
       

     

       115
       115
       +
       	body, _ := json.Marshal(map[string]any{

     

       116
       116
       +
       		"did":    ownerDid,

     

       117
       117
       +
       		"source": source,

     

       118
       118
       +
       		"name":   name,

     

       119
       119
       +
       	})

     

       120
       120
       +
       

     

       121
       121
       +
       	req, err := s.newRequest(Method, endpoint, body)

     

       122
       122
       +
       	if err != nil {

     

       123
       123
       +
       		return nil, err

     

       124
       124
       +
       	}

     

       125
       125
       +
       

     

       126
       126
       +
       	resp, err := s.client.Do(req)

     

       127
       127
       +
       	if err != nil {

     

       128
       128
       +
       		return nil, err

     

       129
       129
       +
       	}

     

       130
       130
       +
       

     

       131
       131
       +
       	var languagePercentages types.RepoLanguageResponse

     

       132
       132
       +
       	if err := json.NewDecoder(resp.Body).Decode(&languagePercentages); err != nil {

     

       133
       133
       +
       		log.Printf("failed to decode fork status: %s", err)

     

       134
       134
       +
       		return nil, err

     

       135
       135
       +
       	}

     

       136
       136
       +
       

     

       137
       137
       +
       	return &languagePercentages, nil

     

       138
       138
       +
       }

     

       139
       139
       +
       

     

       109
       140
        
       func (s *SignedClient) RepoForkAheadBehind(ownerDid, source, name, branch, hiddenRef string) (*http.Response, error) {

     

       110
       141
        
       	const (

     

       111
       142
        
       		Method = "GET"

+4 -3

appview/pages/pages.go

···

       412
       412
        
       	BranchesTrunc []types.Branch

     

       413
       413
        
       	ForkInfo      *types.ForkInfo

     

       414
       414
        
       	types.RepoIndexResponse

     

       415
       415
       -
       	HTMLReadme         template.HTML

     

       416
       416
       -
       	Raw                bool

     

       417
       417
       -
       	EmailToDidOrHandle map[string]string

     

       415
       415
       +
       	HTMLReadme          template.HTML

     

       416
       416
       +
       	Raw                 bool

     

       417
       417
       +
       	EmailToDidOrHandle  map[string]string

     

       418
       418
       +
       	LanguagePercentages map[string]float64

     

       418
       419
        
       }

     

       419
       420
        
       

     

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

+30 -22

appview/state/repo.go

···

       124
       124
        
       	user := s.oauth.GetUser(r)

     

       125
       125
        
       	repoInfo := f.RepoInfo(s, user)

     

       126
       126
        
       

     

       127
       127
       +
       	secret, err := db.GetRegistrationKey(s.db, f.Knot)

     

       128
       128
       +
       	if err != nil {

     

       129
       129
       +
       		log.Printf("failed to get registration key for %s: %s", f.Knot, err)

     

       130
       130
       +
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     

       131
       131
       +
       	}

     

       132
       132
       +
       

     

       133
       133
       +
       	signedClient, err := knotclient.NewSignedClient(f.Knot, secret, s.config.Core.Dev)

     

       134
       134
       +
       	if err != nil {

     

       135
       135
       +
       		log.Printf("failed to create signed client for %s: %s", f.Knot, err)

     

       136
       136
       +
       		return

     

       137
       137
       +
       	}

     

       138
       138
       +
       

     

       127
       139
        
       	var forkInfo *types.ForkInfo

     

       128
       140
        
       	if user != nil && (repoInfo.Roles.IsOwner() || repoInfo.Roles.IsCollaborator()) {

     

       129
       129
       -
       		forkInfo, err = getForkInfo(repoInfo, s, f, w, user)

     

       141
       141
       +
       	forkInfo, err = getForkInfo(repoInfo, s, f, w, user, signedClient)

     

       130
       142
        
       		if err != nil {

     

       131
       143
        
       			log.Printf("Failed to fetch fork information: %v", err)

     

       132
       144
        
       			return

     

       133
       145
        
       		}

     

       146
       146
       +
       	}

     

       147
       147
       +
       

     

       148
       148
       +
       	repoLanguages, err := signedClient.RepoLanguages(user.Did, string(f.RepoAt), repoInfo.Name, f.Ref)

     

       149
       149
       +
       	if err != nil {

     

       150
       150
       +
       		log.Printf("failed to compute language percentages: %s", err)

     

       151
       151
       +
       		return

     

       134
       152
        
       	}

     

       135
       153
        
       

     

       136
       154
        
       	s.pages.RepoIndexPage(w, pages.RepoIndexParams{

     

       137
       137
       -
       		LoggedInUser:       user,

     

       138
       138
       -
       		RepoInfo:           repoInfo,

     

       139
       139
       -
       		TagMap:             tagMap,

     

       140
       140
       -
       		RepoIndexResponse:  result,

     

       141
       141
       -
       		CommitsTrunc:       commitsTrunc,

     

       142
       142
       -
       		TagsTrunc:          tagsTrunc,

     

       143
       143
       -
       		ForkInfo:           forkInfo,

     

       144
       144
       -
       		BranchesTrunc:      branchesTrunc,

     

       145
       145
       -
       		EmailToDidOrHandle: EmailToDidOrHandle(s, emails),

     

       155
       155
       +
       		LoggedInUser:        user,

     

       156
       156
       +
       		RepoInfo:            repoInfo,

     

       157
       157
       +
       		TagMap:              tagMap,

     

       158
       158
       +
       		RepoIndexResponse:   result,

     

       159
       159
       +
       		CommitsTrunc:        commitsTrunc,

     

       160
       160
       +
       		TagsTrunc:           tagsTrunc,

     

       161
       161
       +
       		ForkInfo:            forkInfo,

     

       162
       162
       +
       		BranchesTrunc:       branchesTrunc,

     

       163
       163
       +
       		EmailToDidOrHandle:  EmailToDidOrHandle(s, emails),

     

       164
       164
       +
       		LanguagePercentages: repoLanguages.Languages,

     

       146
       165
        
       	})

     

       147
       166
        
       	return

     

       148
       167
        
       }

     
···

       153
       172
        
       	f *FullyResolvedRepo,

     

       154
       173
        
       	w http.ResponseWriter,

     

       155
       174
        
       	user *oauth.User,

     

       175
       175
       +
       	signedClient *knotclient.SignedClient,

     

       156
       176
        
       ) (*types.ForkInfo, error) {

     

       157
       177
        
       	if user == nil {

     

       158
       178
        
       		return nil, nil

     
···

       161
       181
        
       	forkInfo := types.ForkInfo{

     

       162
       182
        
       		IsFork: repoInfo.Source != nil,

     

       163
       183
        
       		Status: types.UpToDate,

     

       164
       164
       -
       	}

     

       165
       165
       -
       

     

       166
       166
       -
       	secret, err := db.GetRegistrationKey(s.db, f.Knot)

     

       167
       167
       -
       	if err != nil {

     

       168
       168
       -
       		log.Printf("failed to get registration key for %s: %s", f.Knot, err)

     

       169
       169
       -
       		s.pages.Notice(w, "resubmit-error", "Failed to create pull request. Try again later.")

     

       170
       184
        
       	}

     

       171
       185
        
       

     

       172
       186
        
       	if !forkInfo.IsFork {

     
···

       204
       218
        
       	}) {

     

       205
       219
        
       		forkInfo.Status = types.MissingBranch

     

       206
       220
        
       		return &forkInfo, nil

     

       207
       207
       -
       	}

     

       208
       208
       -
       

     

       209
       209
       -
       	signedClient, err := knotclient.NewSignedClient(f.Knot, secret, s.config.Core.Dev)

     

       210
       210
       -
       	if err != nil {

     

       211
       211
       -
       		log.Printf("failed to create signed client for %s: %s", f.Knot, err)

     

       212
       212
       -
       		return nil, err

     

       213
       221
        
       	}

     

       214
       222
        
       

     

       215
       223
        
       	newHiddenRefResp, err := signedClient.NewHiddenRef(user.Did, repoInfo.Name, f.Ref, f.Ref)