keysd_rs 0.1.0

gPRC based keysd integration library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

package client

import (
	"context"
	"encoding/json"
	"fmt"
	"net/url"
	"strconv"

	"github.com/keys-pub/keys"
	"github.com/keys-pub/keys-ext/http/api"
	"github.com/keys-pub/keys/dstore"
	"github.com/keys-pub/keys/dstore/events"
)

// MessageSend sends an encrypted message to a channel.
func (c *Client) MessageSend(ctx context.Context, message *api.Message, sender *keys.EdX25519Key, channel *keys.EdX25519Key) error {
	encrypted, err := message.Encrypt(sender, channel.ID())
	if err != nil {
		return err
	}

	path := dstore.Path("channel", channel.ID(), "msgs")
	vals := url.Values{}
	// vals.Set("expire", expire.String())
	if _, err := c.req(ctx, request{Method: "POST", Path: path, Params: vals, Body: encrypted, Key: channel}); err != nil {
		return err
	}
	return nil
}

// MessagesOpts options for Messages.
type MessagesOpts struct {
	// Index to list to/from
	Index int64
	// Order ascending or descending
	Order events.Direction
	// Limit by
	Limit int
}

// Messages returns encrypted messages (as event.Event) and current index from a
// previous index.
// If truncated, there are more results if you call again with the new index.
// To decrypt to api.Event, use api.DecryptMessageFromEvent.
func (c *Client) Messages(ctx context.Context, channel *keys.EdX25519Key, opts *MessagesOpts) (*api.Events, error) {
	path := dstore.Path("channel", channel.ID(), "msgs")
	return c.events(ctx, path, channel, opts)
}

func (c *Client) events(ctx context.Context, path string, key *keys.EdX25519Key, opts *MessagesOpts) (*api.Events, error) {
	if opts == nil {
		opts = &MessagesOpts{}
	}

	params := url.Values{}
	if opts.Index != 0 {
		params.Add("idx", strconv.FormatInt(opts.Index, 10))
	}
	if opts.Order != "" {
		params.Add("order", string(opts.Order))
	}
	if opts.Limit != 0 {
		params.Add("limit", fmt.Sprintf("%d", opts.Limit))
	}

	resp, err := c.req(ctx, request{
		Method: "GET",
		Path:   path,
		Params: params,
		Key:    key,
	})
	if err != nil {
		return nil, err
	}
	if resp == nil {
		return nil, nil
	}

	var out api.Events
	if err := json.Unmarshal(resp.Data, &out); err != nil {
		return nil, err
	}

	return &out, nil
}