user.go

package mixin

import (
	"context"
	"crypto"
	"crypto/ed25519"
	"crypto/rsa"
	"crypto/x509"
	"encoding/base64"
	"encoding/pem"
	"fmt"
	"time"
)

type User struct {
	UserID         string    `json:"user_id,omitempty"`
	IdentityNumber string    `json:"identity_number,omitempty"`
	Phone          string    `json:"phone,omitempty"`
	FullName       string    `json:"full_name,omitempty"`
	Biography      string    `json:"biography,omitempty"`
	AvatarURL      string    `json:"avatar_url,omitempty"`
	Relationship   string    `json:"relationship,omitempty"`
	MuteUntil      time.Time `json:"mute_until,omitempty"`
	CreatedAt      time.Time `json:"created_at,omitempty"`
	IsVerified     bool      `json:"is_verified,omitempty"`
	SessionID      string    `json:"session_id,omitempty"`
	PinToken       string    `json:"pin_token,omitempty"`
	CodeID         string    `json:"code_id,omitempty"`
	CodeURL        string    `json:"code_url,omitempty"`
	HasPin         bool      `json:"has_pin,omitempty"`

	App *App `json:"app,omitempty"`
}

func (c *Client) UserMe(ctx context.Context) (*User, error) {
	var user User
	if err := c.Get(ctx, "/me", nil, &user); err != nil {
		return nil, err
	}

	return &user, nil
}

func UserMe(ctx context.Context, accessToken string) (*User, error) {
	return NewFromAccessToken(accessToken).UserMe(ctx)
}

func (c *Client) ReadUser(ctx context.Context, userIdOrIdentityNumber string) (*User, error) {
	uri := fmt.Sprintf("/users/%s", userIdOrIdentityNumber)

	var user User
	if err := c.Get(ctx, uri, nil, &user); err != nil {
		return nil, err
	}

	return &user, nil
}

func (c *Client) ReadUsers(ctx context.Context, ids ...string) ([]*User, error) {
	if len(ids) == 0 {
		return nil, nil
	}

	var users []*User
	if err := c.Get(ctx, "/users/fetch", nil, &users); err != nil {
		return nil, err
	}

	return users, nil
}

func (c *Client) ReadFriends(ctx context.Context) ([]*User, error) {
	var users []*User
	if err := c.Get(ctx, "/friends", nil, &users); err != nil {
		return nil, err
	}

	return users, nil
}

// deprecated. Use ReadUser() instead
func (c *Client) SearchUser(ctx context.Context, identityNumber string) (*User, error) {
	return c.ReadUser(ctx, identityNumber)
}

func (c *Client) CreateUser(ctx context.Context, key crypto.Signer, fullname string) (*User, *Keystore, error) {
	publicKey := key.Public()
	var pub []byte
	switch k := publicKey.(type) {
	case ed25519.PublicKey:
		pub = k
	case *rsa.PublicKey:
		var err error
		pub, err = x509.MarshalPKIXPublicKey(publicKey)
		if err != nil {
			return nil, nil, err
		}
	default:
		return nil, nil, fmt.Errorf("unexpected public key type: %T", key)
	}

	paras := map[string]interface{}{
		"session_secret": base64.StdEncoding.EncodeToString(pub),
		"full_name":      fullname,
	}

	var user User
	if err := c.Post(ctx, "/users", paras, &user); err != nil {
		return nil, nil, err
	}

	return &user, newKeystoreFromUser(&user, key), nil
}

func newKeystoreFromUser(user *User, privateKey crypto.PrivateKey) *Keystore {
	var pk string
	switch k := privateKey.(type) {
	case ed25519.PrivateKey:
		pk = ed25519Encoding.EncodeToString(k)
	case *rsa.PrivateKey:
		s := pem.EncodeToMemory(&pem.Block{
			Type:  "RSA PRIVATE KEY",
			Bytes: x509.MarshalPKCS1PrivateKey(k),
		})
		pk = string(s)
	}

	return &Keystore{
		ClientID:   user.UserID,
		SessionID:  user.SessionID,
		PinToken:   user.PinToken,
		PrivateKey: pk,
	}
}

func (c *Client) ModifyProfile(ctx context.Context, fullname, avatarBase64 string) (*User, error) {
	params := map[string]interface{}{}
	if fullname != "" {
		params["full_name"] = fullname
	}
	if avatarBase64 != "" {
		params["avatar_base64"] = avatarBase64
	}

	var user User
	if err := c.Post(ctx, "/me", params, &user); err != nil {
		return nil, err
	}

	return &user, nil
}