Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
8.8 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

package adminapi

import (
	"context"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"net/http"
	"net/url"
	"strings"
	"time"
)

const configPath = "/admin/instance/config"

func (c *Client) Config(ctx context.Context) (*InstanceConfigResponse, error) {
	var resp InstanceConfigResponse
	if err := c.Call(ctx, http.MethodGet, configPath, nil, nil, &resp); err != nil {
		return nil, err
	}
	return &resp, nil
}

func (c *Client) RawConfig(ctx context.Context) (map[string]any, error) {
	var resp map[string]any
	if err := c.Call(ctx, http.MethodGet, configPath, nil, nil, &resp); err != nil {
		return nil, err
	}
	return resp, nil
}

func (c *Client) PatchConfig(ctx context.Context, patch any) error {
	return c.Call(ctx, http.MethodPatch, configPath, nil, patch, nil)
}

func (c *Client) PatchConfigWithWarnings(ctx context.Context, patch any) ([]string, error) {
	var resp struct {
		Warnings []string `json:"warnings"`
	}
	if err := c.Call(ctx, http.MethodPatch, configPath, nil, patch, &resp); err != nil {
		return nil, err
	}
	return resp.Warnings, nil
}

var RegistrationModes = []string{"open", "approval", "invite", "closed"}

func RegistrationPatch(mode string) (map[string]any, error) {
	var apiMode string
	links := true
	switch mode {
	case "open", "approval":
		apiMode = mode
	case "invite":
		apiMode = "closed"
	case "closed":
		apiMode = "closed"
		links = false
	default:
		return nil, fmt.Errorf("adminapi: unknown registration mode %q", mode)
	}
	return map[string]any{"registration": map[string]any{
		"mode":                            apiMode,
		"admin_registration_urls_enabled": links,
	}}, nil
}

type Invite struct {
	ID        string  `json:"id"`
	URL       string  `json:"url"`
	Label     string  `json:"label,omitempty"`
	Uses      int     `json:"uses"`
	MaxUses   *int    `json:"max_uses"`
	ExpiresAt *string `json:"expires_at"`
	CreatedAt string  `json:"created_at"`
}

func InviteURL(origin, id string) string {
	return strings.TrimRight(origin, "/") + "/register?registration_url=" + url.QueryEscape(id)
}

func rfc3339(t *time.Time) *string {
	if t == nil {
		return nil
	}
	s := t.UTC().Format(time.RFC3339)
	return &s
}

func (c *Client) ListInvites(ctx context.Context, origin string) ([]Invite, error) {
	cfg, err := c.Config(ctx)
	if err != nil {
		return nil, err
	}
	out := []Invite{}
	now := time.Now()
	for _, u := range cfg.Registration.Urls {
		if u.RevokedAt != nil {
			continue
		}
		if u.ExpiresAt != nil && u.ExpiresAt.Before(now) {
			continue
		}
		inv := Invite{
			ID:        u.Id,
			URL:       InviteURL(origin, u.Id),
			Uses:      u.UseCount,
			MaxUses:   u.MaxUses,
			ExpiresAt: rfc3339(u.ExpiresAt),
			CreatedAt: u.CreatedAt.UTC().Format(time.RFC3339),
		}
		if u.Label != nil {
			inv.Label = *u.Label
		}
		out = append(out, inv)
	}
	return out, nil
}

type InviteOptions struct {
	Uses    int
	Expires time.Duration
	Label   string
}

func (c *Client) CreateInvite(ctx context.Context, opts InviteOptions) (*Invite, error) {
	req := CreateRegistrationUrlRequest{}
	if opts.Uses > 0 {
		uses := opts.Uses
		req.MaxUses = &uses
	}
	if opts.Expires > 0 {
		at := time.Now().Add(opts.Expires).UTC().Truncate(time.Second)
		req.ExpiresAt = &at
	}
	if opts.Label != "" {
		label := opts.Label
		req.Label = &label
	}
	var resp CreateRegistrationUrlResponse
	if err := c.Call(ctx, http.MethodPost, "/admin/instance/registration-urls", nil, req, &resp); err != nil {
		return nil, err
	}
	u := resp.RegistrationUrl
	inv := &Invite{
		ID:        u.Id,
		URL:       resp.Url,
		Uses:      u.UseCount,
		MaxUses:   u.MaxUses,
		ExpiresAt: rfc3339(u.ExpiresAt),
		CreatedAt: u.CreatedAt.UTC().Format(time.RFC3339),
	}
	if u.Label != nil {
		inv.Label = *u.Label
	}
	return inv, nil
}

type InviteNotFoundError struct{ ID string }

func (e *InviteNotFoundError) Error() string { return fmt.Sprintf("adminapi: no invite %q", e.ID) }

func (c *Client) RevokeInvite(ctx context.Context, id string) error {
	cfg, err := c.Config(ctx)
	if err != nil {
		return err
	}
	for _, u := range cfg.Registration.Urls {
		if u.Id != id {
			continue
		}
		if u.RevokedAt != nil {
			return nil
		}
		return c.Call(ctx, http.MethodDelete, "/admin/instance/registration-urls/"+url.PathEscape(id), nil, nil, nil)
	}
	return &InviteNotFoundError{ID: id}
}

type PendingRegistration struct {
	ID          string `json:"id"`
	Username    string `json:"username"`
	Email       string `json:"email,omitempty"`
	RequestedAt string `json:"requested_at"`
}

func (c *Client) PendingRegistrations(ctx context.Context) ([]PendingRegistration, error) {
	var resp PendingRegistrationListResponse
	if err := c.Call(ctx, http.MethodGet, "/admin/instance/pending-registrations", nil, nil, &resp); err != nil {
		return nil, err
	}
	out := []PendingRegistration{}
	for _, p := range resp.PendingRegistrations {
		pr := PendingRegistration{ID: p.UserId, Username: p.Username, RequestedAt: p.RequestedAt.UTC().Format(time.RFC3339)}
		if p.Email != nil {
			pr.Email = *p.Email
		}
		out = append(out, pr)
	}
	return out, nil
}

type PendingNotFoundError struct{ ID string }

func (e *PendingNotFoundError) Error() string {
	return fmt.Sprintf("adminapi: no pending registration %q", e.ID)
}

func (c *Client) ReviewRegistration(ctx context.Context, id string, approve bool) (*PendingRegistration, error) {
	pending, err := c.PendingRegistrations(ctx)
	if err != nil {
		return nil, err
	}
	var found *PendingRegistration
	for i := range pending {
		if pending[i].ID == id || strings.EqualFold(pending[i].Username, id) {
			found = &pending[i]
			break
		}
	}
	if found == nil {
		return nil, &PendingNotFoundError{ID: id}
	}
	status := Rejected
	if approve {
		status = Approved
	}
	req := PendingRegistrationActionRequest{Status: status}
	if err := c.Call(ctx, http.MethodPatch, "/admin/instance/pending-registrations/"+url.PathEscape(found.ID), nil, req, nil); err != nil {
		return nil, err
	}
	return found, nil
}

type SMTPSettings struct {
	Host     string
	Port     int
	TLS      string
	Username string
	Password string
	FromName string
	FromAddr string
}

var TLSModes = []string{"starttls", "implicit", "opportunistic", "none"}

func TLSModeFor(port int) string {
	if port == 465 {
		return "implicit"
	}
	return "starttls"
}

func StartTLSFailed(message string) bool {
	return strings.Contains(strings.ToLower(message), "starttls")
}

func (c *Client) SavedTLSMode(ctx context.Context, host string, port int) (string, error) {
	cfg, err := c.RawConfig(ctx)
	if err != nil {
		return "", err
	}
	savedHost, _ := lookup(cfg, "integrations.email.smtp.host")
	savedPort, _ := lookup(cfg, "integrations.email.smtp.port")
	mode, _ := lookup(cfg, "integrations.email.smtp.tls_mode")
	h, _ := savedHost.(string)
	n, _ := savedPort.(float64)
	m, _ := mode.(string)
	if !strings.EqualFold(h, host) || int(n) != port {
		return "", nil
	}
	return m, nil
}

func (c *Client) SetSMTP(ctx context.Context, s SMTPSettings) error {
	tls := s.TLS
	if tls == "" {
		tls = TLSModeFor(s.Port)
	}
	smtp := map[string]any{
		"host":     s.Host,
		"port":     s.Port,
		"tls_mode": tls,
		"username": s.Username,
	}
	if s.Password != "" {
		smtp["password"] = s.Password
	}
	email := map[string]any{
		"delivery":   "smtp",
		"from_email": s.FromAddr,
		"smtp":       smtp,
	}
	if s.FromName != "" {
		email["from_name"] = s.FromName
	}
	return c.PatchConfig(ctx, map[string]any{"integrations": map[string]any{"email": email}})
}

func (c *Client) EmailOff(ctx context.Context) error {
	return c.PatchConfig(ctx, map[string]any{"integrations": map[string]any{"email": map[string]any{"delivery": "off"}}})
}

type SMTPTestResult struct {
	OK             bool
	Error          string
	ServerResponse string
}

func (c *Client) TestSMTP(ctx context.Context, sendTo string) (*SMTPTestResult, error) {
	req := InstanceEmailSmtpTestRequest{}
	if sendTo != "" {
		to := EmailType(sendTo)
		req.SendTo = &to
	}
	var resp InstanceEmailSmtpTestResponse
	if err := c.Call(ctx, http.MethodPost, "/admin/instance/config/smtp-tests", nil, req, &resp); err != nil {
		return nil, err
	}
	out := &SMTPTestResult{OK: resp.Ok}
	if resp.Error != nil {
		out.Error = *resp.Error
	}
	if resp.ServerResponse != nil {
		out.ServerResponse = *resp.ServerResponse
	}
	return out, nil
}

func (c *Client) UploadBranding(ctx context.Context, kind BrandingAssetUploadRequestKind, image []byte) error {
	data := base64.StdEncoding.EncodeToString(image)
	req := BrandingAssetUploadRequest{Kind: kind, Image: &data}
	var resp json.RawMessage
	return c.Call(ctx, http.MethodPost, "/admin/instance/config/branding-assets", nil, req, &resp)
}

func (c *Client) SetBranding(ctx context.Context, name, colour string) error {
	branding := map[string]any{}
	if name != "" {
		branding["product_name"] = name
	}
	if colour != "" {
		branding["theme_color"] = colour
	}
	if len(branding) == 0 {
		return nil
	}
	return c.PatchConfig(ctx, map[string]any{"app_public": map[string]any{"branding": branding}})
}