326 lines
10 KiB
Go
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
|
|
}
|