commit 0035de0bf58c7495858661e0af800e4a5feadebb · notnite.com/core

+10 -9

appview/db/email.go

···

       67
       67
        
       	return did, nil

     

       68
       68
        
       }

     

       69
       69
        
       

     

       70
       70
       -
       func GetDidsForEmails(e Execer, ems []string) ([]string, error) {

     

       70
       70
       +
       func GetEmailToDid(e Execer, ems []string) (map[string]string, error) {

     

       71
       71
        
       	if len(ems) == 0 {

     

       72
       72
       -
       		return []string{}, nil

     

       72
       72
       +
       		return make(map[string]string), nil

     

       73
       73
        
       	}

     

       74
       74
        
       

     

       75
       75
        
       	// Create placeholders for the IN clause

     

       76
       76
        
       	placeholders := make([]string, len(ems))

     

       77
       77
       -
       	args := make([]interface{}, len(ems))

     

       77
       77
       +
       	args := make([]any, len(ems))

     

       78
       78
        
       	for i, em := range ems {

     

       79
       79
        
       		placeholders[i] = "?"

     

       80
       80
        
       		args[i] = em

     

       81
       81
        
       	}

     

       82
       82
        
       

     

       83
       83
        
       	query := `

     

       84
       84
       -
       		select did

     

       84
       84
       +
       		select email, did

     

       85
       85
        
       		from emails

     

       86
       86
        
       		where email in (` + strings.Join(placeholders, ",") + `)

     

       87
       87
        
       	`

     
···

       92
       92
        
       	}

     

       93
       93
        
       	defer rows.Close()

     

       94
       94
        
       

     

       95
       95
       -
       	var dids []string

     

       95
       95
       +
       	assoc := make(map[string]string)

     

       96
       96
       +
       

     

       96
       97
        
       	for rows.Next() {

     

       97
       97
       -
       		var did string

     

       98
       98
       -
       		if err := rows.Scan(&did); err != nil {

     

       98
       98
       +
       		var email, did string

     

       99
       99
       +
       		if err := rows.Scan(&email, &did); err != nil {

     

       99
       100
        
       			return nil, err

     

       100
       101
        
       		}

     

       101
       101
       -
       		dids = append(dids, did)

     

       102
       102
       +
       		assoc[email] = did

     

       102
       103
        
       	}

     

       103
       104
        
       

     

       104
       105
        
       	if err := rows.Err(); err != nil {

     

       105
       106
        
       		return nil, err

     

       106
       107
        
       	}

     

       107
       108
        
       

     

       108
       108
       -
       	return dids, nil

     

       109
       109
       +
       	return assoc, nil

     

       109
       110
        
       }

     

       110
       111
        
       

     

       111
       112
        
       func GetVerificationCodeForEmail(e Execer, did string, email string) (string, error) {

+4 -3

appview/pages/templates/repo/commit.html

···

       20
       20
        
       

     

       21
       21
        
         <div class="flex items-center">

     

       22
       22
        
             <p class="text-sm text-gray-500">

     

       23
       23
       -
                 {{ if index .EmailToDidOrHandle $commit.Author.Email }}

     

       24
       24
       -
                   {{ $handle := index .EmailToDidOrHandle $commit.Author.Email }}

     

       25
       25
       -
                   <a href="/@{{ $handle }}" class="no-underline hover:underline text-gray-500">@{{ $handle }}</a>

     

       23
       23
       +
                 {{ $didOrHandle := index $.EmailToDidOrHandle $commit.Author.Email }}

     

       24
       24
       +
       

     

       25
       25
       +
                 {{ if $didOrHandle }}

     

       26
       26
       +
                   <a href="/{{ $didOrHandle }}" class="no-underline hover:underline text-gray-500">{{ $didOrHandle }}</a>

     

       26
       27
        
                 {{ else }}

     

       27
       28
        
                   <a href="mailto:{{ $commit.Author.Email }}" class="no-underline hover:underline text-gray-500">{{ $commit.Author.Name }}</a>

     

       28
       29
        
                 {{ end }}

+3 -3

appview/pages/templates/repo/index.html

···

       164
       164
        
                             class="mx-2 before:content-['·'] before:select-none"

     

       165
       165
        
                         ></span>

     

       166
       166
        
                         <span>

     

       167
       167
       -
                             {{ $handle := index $.EmailToDidOrHandle .Author.Email }}

     

       167
       167
       +
                             {{ $didOrHandle := index $.EmailToDidOrHandle .Author.Email }}

     

       168
       168
        
                             <a

     

       169
       169
       -
                                 href="{{ if $handle }}/@{{ $handle }}{{ else }}mailto:{{ .Author.Email }}{{ end }}"

     

       169
       169
       +
                                 href="{{ if $didOrHandle }}/{{ $didOrHandle }}{{ else }}mailto:{{ .Author.Email }}{{ end }}"

     

       170
       170
        
                                 class="text-gray-500 no-underline hover:underline"

     

       171
       171
       -
                                 >{{ if $handle }}@{{ $handle }}{{ else }}{{ .Author.Name }}{{ end }}</a

     

       171
       171
       +
                                 >{{ if $didOrHandle }}{{ $didOrHandle }}{{ else }}{{ .Author.Name }}{{ end }}</a

     

       172
       172
        
                             >

     

       173
       173
        
                         </span>

     

       174
       174
        
                         <div

+8 -8

appview/pages/templates/repo/log.html

···

       25
       25
        
                   </span>

     

       26
       26
        
                   <span class="mx-2 before:content-['·'] before:select-none"></span>

     

       27
       27
        
                   <span>

     

       28
       28
       -
                       {{ $handle := index $.EmailToDidOrHandle $commit.Author.Email }}

     

       29
       29
       -
                       {{ if $handle }}

     

       28
       28
       +
                       {{ $didOrHandle := index $.EmailToDidOrHandle $commit.Author.Email }}

     

       29
       29
       +
                       {{ if $didOrHandle }}

     

       30
       30
        
                       <a

     

       31
       31
       -
                           href="/@{{ $handle }}"

     

       31
       31
       +
                           href="/{{ $didOrHandle }}"

     

       32
       32
        
                           class="text-gray-500 no-underline hover:underline"

     

       33
       33
       -
                           >@{{ $handle }}</a

     

       33
       33
       +
                           >{{ $didOrHandle }}</a

     

       34
       34
        
                       >

     

       35
       35
        
                       {{ else }}

     

       36
       36
        
                       <a

     
···

       105
       105
        
                                       class="mx-2 before:content-['·'] before:select-none"

     

       106
       106
        
                                   ></span>

     

       107
       107
        
                                   <span>

     

       108
       108
       -
                                       {{ $handle := index $.EmailToDidOrHandle .Author.Email }}

     

       109
       109
       -
                                       {{ if $handle }}

     

       108
       108
       +
                                       {{ $didOrHandle := index $.EmailToDidOrHandle .Author.Email }}

     

       109
       109
       +
                                       {{ if $didOrHandle }}

     

       110
       110
        
                                       <a

     

       111
       111
       -
                                           href="/@{{ $handle }}"

     

       111
       111
       +
                                           href="/{{ $didOrHandle }}"

     

       112
       112
        
                                           class="text-gray-500 no-underline hover:underline"

     

       113
       113
       -
                                           >@{{ $handle }}</a

     

       113
       113
       +
                                           >{{ $didOrHandle }}</a

     

       114
       114
        
                                       >

     

       115
       115
        
                                       {{ else }}

     

       116
       116
        
                                       <a

+18 -13

appview/state/repo_util.go

···

       81
       81
        
       }

     

       82
       82
        
       

     

       83
       83
        
       func EmailToDidOrHandle(s *State, emails []string) map[string]string {

     

       84
       84
       -
       	dids, err := db.GetDidsForEmails(s.db, emails)

     

       84
       84
       +
       	emailToDid, err := db.GetEmailToDid(s.db, emails)

     

       85
       85
        
       	if err != nil {

     

       86
       86
        
       		log.Printf("error fetching dids for emails: %v", err)

     

       87
       87
        
       		return nil

     

       88
       88
        
       	}

     

       89
       89
        
       

     

       90
       90
       +
       	log.Println(emailToDid)

     

       91
       91
       +
       	var dids []string

     

       92
       92
       +
       	for _, v := range emailToDid {

     

       93
       93
       +
       		dids = append(dids, v)

     

       94
       94
       +
       	}

     

       95
       95
       +
       	log.Println(dids)

     

       96
       96
       +
       	resolvedIdents := s.resolver.ResolveIdents(context.Background(), dids)

     

       97
       97
       +
       

     

       90
       98
        
       	didHandleMap := make(map[string]string)

     

       91
       91
       -
       	emailToDid := make(map[string]string)

     

       92
       92
       -
       	resolvedIdents := s.resolver.ResolveIdents(context.Background(), dids)

     

       93
       93
       -
       	for i, resolved := range resolvedIdents {

     

       94
       94
       -
       		if resolved != nil {

     

       95
       95
       -
       			didHandleMap[dids[i]] = resolved.Handle.String()

     

       96
       96
       -
       			if i < len(emails) {

     

       97
       97
       -
       				emailToDid[emails[i]] = dids[i]

     

       98
       98
       -
       			}

     

       99
       99
       +
       	for _, identity := range resolvedIdents {

     

       100
       100
       +
       		if !identity.Handle.IsInvalidHandle() {

     

       101
       101
       +
       			didHandleMap[identity.DID.String()] = fmt.Sprintf("@%s", identity.Handle.String())

     

       102
       102
       +
       		} else {

     

       103
       103
       +
       			didHandleMap[identity.DID.String()] = identity.DID.String()

     

       99
       104
        
       		}

     

       100
       105
        
       	}

     

       101
       106
        
       

     

       102
       107
        
       	// Create map of email to didOrHandle for commit display

     

       103
       108
        
       	emailToDidOrHandle := make(map[string]string)

     

       104
       109
        
       	for email, did := range emailToDid {

     

       105
       105
       -
       		if handle, ok := didHandleMap[did]; ok {

     

       106
       106
       -
       			emailToDidOrHandle[email] = handle

     

       107
       107
       -
       		} else {

     

       108
       108
       -
       			emailToDidOrHandle[email] = did

     

       110
       110
       +
       		if didOrHandle, ok := didHandleMap[did]; ok {

     

       111
       111
       +
       			emailToDidOrHandle[email] = didOrHandle

     

       109
       112
        
       		}

     

       110
       113
        
       	}

     

       114
       114
       +
       

     

       115
       115
       +
       	log.Println(emailToDidOrHandle)

     

       111
       116
        
       

     

       112
       117
        
       	return emailToDidOrHandle

     

       113
       118
        
       }