pstuifzand/ekster

package client

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "net/http/httputil"
    "net/url"
    "strings"

    "p83.nl/go/ekster/pkg/microsub"
    "p83.nl/go/ekster/pkg/sse"
)

// Client is a HTTP client for Microsub
type Client struct {
    Me               *url.URL
    MicrosubEndpoint *url.URL
    Token            string

    Logging bool
}

func (c *Client) microsubGetRequest(action string, args map[string]string) (*http.Response, error) {
    client := http.Client{}

    u := *c.MicrosubEndpoint
    q := u.Query()
    q.Add("action", action)
    for k, v := range args {
        q.Add(k, v)
    }
    u.RawQuery = q.Encode()

    req, err := http.NewRequest(http.MethodGet, u.String(), nil)
    if err != nil {
        return nil, err
    }

    req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", c.Token))

    if c.Logging {
        x, _ := httputil.DumpRequestOut(req, true)
        log.Printf("REQUEST:\n\n%s\n\n", x)
    }

    res, err := client.Do(req)

    if c.Logging {
        x, _ := httputil.DumpResponse(res, true)
        log.Printf("RESPONSE:\n\n%s\n\n", x)
    }

    return res, err
}

func (c *Client) microsubPostRequest(action string, args map[string]string) (*http.Response, error) {
    client := http.Client{}

    u := *c.MicrosubEndpoint
    q := u.Query()
    q.Add("action", action)
    for k, v := range args {
        q.Add(k, v)
    }
    u.RawQuery = q.Encode()

    req, err := http.NewRequest(http.MethodPost, u.String(), nil)
    if err != nil {
        return nil, err
    }

    req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", c.Token))

    if c.Logging {
        x, _ := httputil.DumpRequestOut(req, true)
        log.Printf("REQUEST:\n\n%s\n\n", x)
    }

    res, err := client.Do(req)

    if c.Logging {
        x, _ := httputil.DumpResponse(res, true)
        log.Printf("RESPONSE:\n\n%s\n\n", x)
    }

    if res.StatusCode != 200 {
        msg, _ := ioutil.ReadAll(res.Body)
        return nil, fmt.Errorf("unsuccessful response: %d: %q", res.StatusCode, strings.TrimSpace(string(msg)))
    }

    return res, err
}

func (c *Client) microsubPostFormRequest(action string, args map[string]string, data url.Values) (*http.Response, error) {
    client := http.Client{}

    u := *c.MicrosubEndpoint
    q := u.Query()
    q.Add("action", action)
    for k, v := range args {
        q.Add(k, v)
    }
    u.RawQuery = q.Encode()

    req, err := http.NewRequest(http.MethodPost, u.String(), strings.NewReader(data.Encode()))
    if err != nil {
        return nil, err
    }

    req.Header.Add("Authorization", fmt.Sprintf("Bearer %s", c.Token))

    res, err := client.Do(req)

    if res.StatusCode != 200 {
        msg, _ := ioutil.ReadAll(res.Body)
        return nil, fmt.Errorf("unsuccessful response: %d: %q", res.StatusCode, strings.TrimSpace(string(msg)))
    }

    return res, err
}

// ChannelsGetList gets the channels from a Microsub server
func (c *Client) ChannelsGetList() ([]microsub.Channel, error) {
    args := make(map[string]string)
    res, err := c.microsubGetRequest("channels", args)
    if err != nil {
        return []microsub.Channel{}, err
    }
    defer res.Body.Close()
    if res.StatusCode != 200 {
        body, err := ioutil.ReadAll(res.Body)
        if err != nil {
            return []microsub.Channel{}, fmt.Errorf("HTTP Status is not 200, but %d, error while reading body", res.StatusCode)
        }
        return []microsub.Channel{}, fmt.Errorf("HTTP Status is not 200, but %d: %s", res.StatusCode, body)
    }

    type channelsResponse struct {
        Channels []microsub.Channel `json:"channels"`
    }

    dec := json.NewDecoder(res.Body)
    var channels channelsResponse
    err = dec.Decode(&channels)

    return channels.Channels, err
}

// TimelineGet gets a timeline from a Microsub server
func (c *Client) TimelineGet(before, after, channel string) (microsub.Timeline, error) {
    args := make(map[string]string)
    args["after"] = after
    args["before"] = before
    args["channel"] = channel
    res, err := c.microsubGetRequest("timeline", args)
    if err != nil {
        return microsub.Timeline{}, err
    }
    defer res.Body.Close()
    if res.StatusCode != 200 {
        body, err := ioutil.ReadAll(res.Body)
        if err != nil {
            return microsub.Timeline{}, fmt.Errorf("HTTP Status is not 200, but %d, error while reading body", res.StatusCode)
        }
        return microsub.Timeline{}, fmt.Errorf("HTTP Status is not 200, but %d: %s", res.StatusCode, body)
    }
    dec := json.NewDecoder(res.Body)
    var timeline microsub.Timeline
    err = dec.Decode(&timeline)
    if err != nil {
        return microsub.Timeline{}, err
    }
    return timeline, nil
}

// PreviewURL gets a Timeline for a url from a Microsub server
func (c *Client) PreviewURL(url string) (microsub.Timeline, error) {
    args := make(map[string]string)
    args["url"] = url
    res, err := c.microsubPostRequest("preview", args)
    if err != nil {
        return microsub.Timeline{}, err
    }
    defer res.Body.Close()

    var timeline microsub.Timeline
    if res.StatusCode != 200 {
        body, err := ioutil.ReadAll(res.Body)
        if err != nil {
            return timeline, fmt.Errorf("HTTP Status is not 200, but %d, error while reading body", res.StatusCode)
        }
        return timeline, fmt.Errorf("HTTP Status is not 200, but %d: %s", res.StatusCode, body)
    }
    dec := json.NewDecoder(res.Body)
    err = dec.Decode(&timeline)
    if err != nil {
        return microsub.Timeline{}, err
    }
    return timeline, nil
}

// FollowGetList gets the list of followed feeds.
func (c *Client) FollowGetList(channel string) ([]microsub.Feed, error) {
    args := make(map[string]string)
    args["channel"] = channel
    res, err := c.microsubGetRequest("follow", args)
    if err != nil {
        return []microsub.Feed{}, nil
    }
    defer res.Body.Close()
    if res.StatusCode != 200 {
        body, err := ioutil.ReadAll(res.Body)
        if err != nil {
            return []microsub.Feed{}, fmt.Errorf("HTTP Status is not 200, but %d, error while reading body", res.StatusCode)
        }
        return []microsub.Feed{}, fmt.Errorf("HTTP Status is not 200, but %d: %s", res.StatusCode, body)
    }
    dec := json.NewDecoder(res.Body)
    type followResponse struct {
        Items []microsub.Feed `json:"items"`
    }
    var response followResponse
    err = dec.Decode(&response)
    if err != nil {
        return []microsub.Feed{}, nil
    }
    return response.Items, nil
}

// ChannelsCreate creates and new channel on a microsub server.
func (c *Client) ChannelsCreate(name string) (microsub.Channel, error) {
    args := make(map[string]string)
    args["name"] = name
    res, err := c.microsubPostRequest("channels", args)
    if err != nil {
        return microsub.Channel{}, nil
    }
    defer res.Body.Close()
    var channel microsub.Channel
    dec := json.NewDecoder(res.Body)
    err = dec.Decode(&channel)
    if err != nil {
        return microsub.Channel{}, nil
    }
    return channel, nil
}

// ChannelsUpdate updates a channel.
func (c *Client) ChannelsUpdate(uid, name string) (microsub.Channel, error) {
    args := make(map[string]string)
    args["name"] = name
    args["channel"] = uid
    res, err := c.microsubPostRequest("channels", args)
    if err != nil {
        return microsub.Channel{}, err
    }
    defer res.Body.Close()
    var channel microsub.Channel
    dec := json.NewDecoder(res.Body)
    err = dec.Decode(&channel)
    if err != nil {
        return microsub.Channel{}, err
    }
    return channel, nil
}

// ChannelsDelete deletes a channel.
func (c *Client) ChannelsDelete(uid string) error {
    args := make(map[string]string)
    args["channel"] = uid
    args["method"] = "delete"
    res, err := c.microsubPostRequest("channels", args)
    if err != nil {
        return err
    }
    res.Body.Close()
    return nil
}

// FollowURL follows a url.
func (c *Client) FollowURL(channel, url string) (microsub.Feed, error) {
    args := make(map[string]string)
    args["channel"] = channel
    args["url"] = url
    res, err := c.microsubPostRequest("follow", args)
    if err != nil {
        return microsub.Feed{}, err
    }
    defer res.Body.Close()
    var feed microsub.Feed
    dec := json.NewDecoder(res.Body)
    err = dec.Decode(&feed)
    if err != nil {
        return microsub.Feed{}, err
    }
    return feed, nil
}

// UnfollowURL unfollows a url in a channel.
func (c *Client) UnfollowURL(channel, url string) error {
    args := make(map[string]string)
    args["channel"] = channel
    args["url"] = url
    res, err := c.microsubPostRequest("unfollow", args)
    if err != nil {
        return err
    }
    res.Body.Close()
    return nil
}

// Search asks the server to search for the query.
func (c *Client) Search(query string) ([]microsub.Feed, error) {
    args := make(map[string]string)
    args["query"] = query
    res, err := c.microsubPostRequest("search", args)
    if err != nil {
        return []microsub.Feed{}, err
    }
    type searchResponse struct {
        Results []microsub.Feed `json:"results"`
    }
    defer res.Body.Close()
    var response searchResponse
    dec := json.NewDecoder(res.Body)
    err = dec.Decode(&response)
    if err != nil {
        return []microsub.Feed{}, err
    }
    return response.Results, nil
}

// ItemSearch send a search request to the server
func (c *Client) ItemSearch(channel, query string) ([]microsub.Item, error) {
    args := make(map[string]string)
    args["query"] = query
    args["channel"] = channel
    res, err := c.microsubPostRequest("search", args)
    if err != nil {
        return []microsub.Item{}, err
    }
    type searchResponse struct {
        Items []microsub.Item `json:"items"`
    }
    defer res.Body.Close()
    var response searchResponse
    dec := json.NewDecoder(res.Body)
    err = dec.Decode(&response)
    if err != nil {
        return []microsub.Item{}, err
    }
    return response.Items, nil
}

// MarkRead marks an item read on the server.
func (c *Client) MarkRead(channel string, uids []string) error {
    args := make(map[string]string)
    args["channel"] = channel
    args["method"] = "mark_read"

    data := url.Values{}
    for _, uid := range uids {
        data.Add("entry[]", uid)
    }

    res, err := c.microsubPostFormRequest("timeline", args, data)
    if err != nil {
        return err
    }
    res.Body.Close()
    return nil
}

// Events open an event channel to the server.
func (c *Client) Events() (chan sse.Message, error) {

    ch := make(chan sse.Message)

    errorCounter := 0
    go func() {
        for {
            res, err := c.microsubGetRequest("events", nil)
            if err != nil {
                log.Printf("could not request events: %+v", err)
                errorCounter++
                if errorCounter > 5 {
                    break
                }
                continue
            }

            err = sse.Reader(res.Body, ch)
            if err != nil {
                log.Printf("could not create reader: %+v", err)
                break
            }
        }

        close(ch)
    }()

    return ch, nil
}