Files

326 lines
10 KiB
Go

package store
import (
"context"
"crypto/sha256"
"database/sql"
"encoding/hex"
"errors"
"sort"
"strings"
"time"
"lektorenplan/domain"
)
// ReaderContact is one reader account together with the person it represents.
// The e-mail address is only filled when the requesting session holds the data
// key for that person, i.e. after the owner shared it.
type ReaderContact struct {
UserID string
Person domain.Person
}
// ReaderDirectory lists the active reader accounts linked to a tenant. The
// contacts are hydrated with the current request's keyring, so addresses that
// were not shared remain empty and locked.
func (s *Store) ReaderDirectory(ctx context.Context, tenantID string) ([]ReaderContact, error) {
rows, err := s.db.QueryContext(ctx, `
SELECT u.id, u.linked_person_id
FROM users u
JOIN people p ON p.tenant_id=u.linked_tenant_id AND p.id=u.linked_person_id
WHERE u.active=1 AND u.role='reader' AND u.linked_tenant_id=?
ORDER BY p.last_name COLLATE NOCASE, p.first_name COLLATE NOCASE, u.id`, tenantID)
if err != nil {
return nil, err
}
type readerRow struct {
userID string
personID string
}
var ids []readerRow
for rows.Next() {
var row readerRow
if err := rows.Scan(&row.userID, &row.personID); err != nil {
rows.Close()
return nil, err
}
ids = append(ids, row)
}
if err := rows.Err(); err != nil {
rows.Close()
return nil, err
}
rows.Close()
out := make([]ReaderContact, 0, len(ids))
for _, row := range ids {
person, err := s.Person(ctx, tenantID, row.personID)
if errors.Is(err, ErrNotFound) {
continue
}
if err != nil {
return nil, err
}
out = append(out, ReaderContact{UserID: row.userID, Person: *person})
}
return out, nil
}
// ReaderForPerson returns the active reader account linked to a person.
func (s *Store) ReaderForPerson(ctx context.Context, tenantID, personID string) (string, bool) {
var userID string
err := s.db.QueryRowContext(ctx, `
SELECT id FROM users
WHERE active=1 AND role='reader' AND linked_tenant_id=? AND linked_person_id=?
ORDER BY id LIMIT 1`, tenantID, personID).Scan(&userID)
if err != nil {
return "", false
}
return userID, true
}
// ContactSharesForOwner lists the reader accounts that may see the owner's
// e-mail address.
func (s *Store) ContactSharesForOwner(ctx context.Context, tenantID, ownerPersonID string) (map[string]bool, error) {
rows, err := s.db.QueryContext(ctx, `
SELECT viewer_user_id FROM contact_shares
WHERE tenant_id=? AND owner_person_id=?`, tenantID, ownerPersonID)
if err != nil {
return nil, err
}
defer rows.Close()
out := map[string]bool{}
for rows.Next() {
var userID string
if err := rows.Scan(&userID); err != nil {
return nil, err
}
out[userID] = true
}
return out, rows.Err()
}
// ContactSharesForViewer lists the persons whose e-mail addresses were shared
// with one reader account.
func (s *Store) ContactSharesForViewer(ctx context.Context, tenantID, viewerUserID string) ([]string, error) {
rows, err := s.db.QueryContext(ctx, `
SELECT owner_person_id FROM contact_shares
WHERE tenant_id=? AND viewer_user_id=? ORDER BY owner_person_id`, tenantID, viewerUserID)
if err != nil {
return nil, err
}
defer rows.Close()
var out []string
for rows.Next() {
var personID string
if err := rows.Scan(&personID); err != nil {
return nil, err
}
out = append(out, personID)
}
return out, rows.Err()
}
func (s *Store) contactShareViewers(ctx context.Context, tenantID, ownerPersonID string) ([]string, error) {
rows, err := s.db.QueryContext(ctx, `
SELECT viewer_user_id FROM contact_shares
WHERE tenant_id=? AND owner_person_id=? ORDER BY viewer_user_id`, tenantID, ownerPersonID)
if err != nil {
return nil, err
}
defer rows.Close()
var out []string
for rows.Next() {
var userID string
if err := rows.Scan(&userID); err != nil {
return nil, err
}
out = append(out, userID)
}
return out, rows.Err()
}
// ContactShareExists reports whether ownerPersonID shared the address with the
// given account.
func (s *Store) ContactShareExists(ctx context.Context, tenantID, ownerPersonID, viewerUserID string) bool {
var count int
err := s.db.QueryRowContext(ctx, `
SELECT COUNT(*) FROM contact_shares
WHERE tenant_id=? AND owner_person_id=? AND viewer_user_id=?`,
tenantID, ownerPersonID, viewerUserID).Scan(&count)
return err == nil && count > 0
}
// SetContactShares replaces the viewer list of one owner. Newly selected
// readers receive the encrypted person scope; removed readers lose their
// wrapper immediately. The returned lists contain the actual changes.
func (s *Store) SetContactShares(ctx context.Context, keyring *Keyring, tenantID, ownerUserID, ownerPersonID string, viewerUserIDs []string) (added, removed []string, err error) {
// Refuse before touching the consent table when the session cannot grant
// the encrypted scope; otherwise a failed save would leave an announced
// share without a usable key.
if s.SecretIsInitialized(ctx, tenantID) && keyring == nil {
return nil, nil, errKeyLocked
}
current, err := s.ContactSharesForOwner(ctx, tenantID, ownerPersonID)
if err != nil {
return nil, nil, err
}
wanted := map[string]bool{}
for _, raw := range viewerUserIDs {
userID := strings.TrimSpace(raw)
if userID == "" || userID == ownerUserID || wanted[userID] {
continue
}
var count int
if err := s.db.QueryRowContext(ctx, `
SELECT COUNT(*) FROM users
WHERE id=? AND active=1 AND role='reader' AND linked_tenant_id=?
AND linked_person_id<>'' AND linked_person_id<>?`,
userID, tenantID, ownerPersonID).Scan(&count); err != nil {
return nil, nil, err
}
if count == 0 {
return nil, nil, errors.New("Ein ausgewähltes Konto ist kein aktiver Leserzugang dieses Mandanten")
}
wanted[userID] = true
}
for userID := range current {
if !wanted[userID] {
removed = append(removed, userID)
}
}
for userID := range wanted {
if !current[userID] {
added = append(added, userID)
}
}
sort.Strings(added)
sort.Strings(removed)
if err := s.transaction(ctx, func(tx *sql.Tx) error {
for _, userID := range removed {
if _, err := tx.ExecContext(ctx, `
DELETE FROM contact_shares
WHERE tenant_id=? AND owner_person_id=? AND viewer_user_id=?`,
tenantID, ownerPersonID, userID); err != nil {
return err
}
}
for _, userID := range added {
if _, err := tx.ExecContext(ctx, `
INSERT INTO contact_shares(tenant_id, owner_person_id, viewer_user_id, granted_at)
VALUES(?, ?, ?, ?)
ON CONFLICT DO NOTHING`,
tenantID, ownerPersonID, userID, time.Now().UTC().Format(time.RFC3339)); err != nil {
return err
}
}
// A pending swap is only possible while both sides still release
// their addresses. Revoking a share cancels affected requests so the
// plan never keeps a swap-requested mark for an impossible swap.
if _, err := tx.ExecContext(ctx, `
UPDATE swap_requests SET status=?, responded_at=?
WHERE tenant_id=? AND status=? AND NOT (
EXISTS (
SELECT 1 FROM contact_shares a
WHERE a.tenant_id=swap_requests.tenant_id
AND a.owner_person_id=swap_requests.target_person_id
AND a.viewer_user_id=swap_requests.requester_user_id
) AND EXISTS (
SELECT 1 FROM contact_shares b
WHERE b.tenant_id=swap_requests.tenant_id
AND b.owner_person_id=swap_requests.requester_person_id
AND b.viewer_user_id=swap_requests.target_user_id
)
)`, SwapCancelled, time.Now().UTC().Format(time.RFC3339), tenantID, SwapPending); err != nil {
return err
}
return nil
}); err != nil {
return nil, nil, err
}
if s.SecretIsInitialized(ctx, tenantID) {
scope := KeyScope{Type: ScopePerson, TenantID: tenantID, ID: ownerPersonID}
if len(added) > 0 {
dek, err := s.ensureScope(ctx, keyring, scope)
if err != nil {
return added, removed, err
}
if err := s.grantScopeDEK(ctx, keyring, scope, dek, added); err != nil {
return added, removed, err
}
}
for _, userID := range removed {
if _, err := s.db.ExecContext(ctx, `
DELETE FROM key_wrappers
WHERE scope_type=? AND tenant_id=? AND scope_id=? AND user_id=?`,
ScopePerson, tenantID, ownerPersonID, userID); err != nil {
return added, removed, err
}
}
}
return added, removed, nil
}
// readerRosterHash fingerprints the current reader accounts of a tenant. The
// owner's own account is excluded.
func (s *Store) readerRosterHash(ctx context.Context, tenantID, ownerUserID string) (string, error) {
rows, err := s.db.QueryContext(ctx, `
SELECT id, linked_person_id FROM users
WHERE active=1 AND role='reader' AND linked_tenant_id=? AND id<>?
ORDER BY id`, tenantID, ownerUserID)
if err != nil {
return "", err
}
defer rows.Close()
hash := sha256.New()
for rows.Next() {
var userID, personID string
if err := rows.Scan(&userID, &personID); err != nil {
return "", err
}
hash.Write([]byte(userID + "|" + personID + "\n"))
}
if err := rows.Err(); err != nil {
return "", err
}
return hex.EncodeToString(hash.Sum(nil)), nil
}
// ContactRosterChanged reports whether the reader directory changed since the
// owner last reviewed the sharing list. known is false before the first save.
func (s *Store) ContactRosterChanged(ctx context.Context, tenantID, ownerUserID, ownerPersonID string) (changed, known bool, err error) {
current, err := s.readerRosterHash(ctx, tenantID, ownerUserID)
if err != nil {
return false, false, err
}
var stored string
err = s.db.QueryRowContext(ctx, `
SELECT roster_hash FROM contact_reviews
WHERE tenant_id=? AND owner_person_id=?`, tenantID, ownerPersonID).Scan(&stored)
if errors.Is(err, sql.ErrNoRows) {
return false, false, nil
}
if err != nil {
return false, false, err
}
return stored != current, true, nil
}
// MarkContactRosterReviewed stores the current reader directory fingerprint.
func (s *Store) MarkContactRosterReviewed(ctx context.Context, tenantID, ownerUserID, ownerPersonID string) error {
hash, err := s.readerRosterHash(ctx, tenantID, ownerUserID)
if err != nil {
return err
}
_, err = s.db.ExecContext(ctx, `
INSERT INTO contact_reviews(tenant_id, owner_person_id, roster_hash, reviewed_at)
VALUES(?, ?, ?, ?)
ON CONFLICT(tenant_id, owner_person_id) DO UPDATE SET
roster_hash=excluded.roster_hash, reviewed_at=excluded.reviewed_at`,
tenantID, ownerPersonID, hash, time.Now().UTC().Format(time.RFC3339))
return err
}