First Commit

internal/models/change.go

@@ -0,0 +1,49 @@
+package models
+
+import (
+	"encoding/json"
+	"errors"
+	"time"
+)
+
+// A Change is a change in the timeline.
+type Change struct {
+	ID      string         `json:"id"`
+	Model   string         `json:"model"`
+	Op      string         `json:"op"`
+	Author  string         `json:"author"`
+	Date    time.Time      `json:"date"`
+	Objects []ChangeObject `json:"objects"`
+}
+
+// A ChangeObject is an object affected by the change.
+type ChangeObject struct {
+	Data     json.RawMessage `json:"-"`
+	TypeName string          `json:"__typename"`
+}
+
+// Channel parses the ChangeObject as a channel.
+func (co *ChangeObject) Channel() (Channel, error) {
+	if co.TypeName != "Channel" {
+		return Channel{}, errors.New("Incorrect Type Name")
+	}
+
+	channel := Channel{}
+	err := json.Unmarshal(co.Data, &channel)
+
+	return channel, err
+}
+
+// UnmarshalJSON implements json.Unmarshaller
+func (co *ChangeObject) UnmarshalJSON(b []byte) error {
+	data := make([]byte, len(b))
+	copy(data, b)
+	co.Data = data
+
+	err := json.Unmarshal(data, co)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}

internal/models/channel.go

@@ -0,0 +1,9 @@
+package models
+
+// Channel represents
+type Channel struct {
+	Name         string
+	Logged       bool
+	EventName    string
+	LocationName string
+}

internal/models/channels/find.go

@@ -0,0 +1,40 @@
+package channels
+
+import (
+	"context"
+	"encoding/json"
+
+	"git.aiterp.net/rpdata/logbot3/internal/api"
+	"git.aiterp.net/rpdata/logbot3/internal/models"
+)
+
+type findResult struct {
+	Channel models.Channel `json:"channel"`
+}
+
+var findGQL = `
+	query FindChannel($name: String!) {
+		channel(name: $name) {
+			name
+			logged
+			eventName
+			locationName
+		}
+	}
+`
+
+// Find finds a channel by name
+func Find(ctx context.Context, name string) (models.Channel, error) {
+	data, err := api.Global().Query(ctx, findGQL, map[string]interface{}{"name": name}, nil)
+	if err != nil {
+		return models.Channel{}, err
+	}
+
+	result := findResult{}
+	err = json.Unmarshal(data, &result)
+	if err != nil {
+		return models.Channel{}, err
+	}
+
+	return result.Channel, nil
+}

internal/models/channels/list-logged.go

@@ -0,0 +1,40 @@
+package channels
+
+import (
+	"context"
+	"encoding/json"
+
+	"git.aiterp.net/rpdata/logbot3/internal/api"
+	"git.aiterp.net/rpdata/logbot3/internal/models"
+)
+
+type listLoggedResult struct {
+	Channels []models.Channel `json:"channels"`
+}
+
+var listLoggedGQL = `
+	query ListLogged {
+		channels(filter: {logged: true}) {
+			name
+			logged
+			eventName
+			locationName
+		}
+	}
+`
+
+// ListLogged gets all open channels
+func ListLogged(ctx context.Context) ([]models.Channel, error) {
+	data, err := api.Global().Query(ctx, listLoggedGQL, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	result := listLoggedResult{}
+	err = json.Unmarshal(data, &result)
+	if err != nil {
+		return nil, err
+	}
+
+	return result.Channels, nil
+}

internal/models/channels/set-logged.go

@@ -0,0 +1,40 @@
+package channels
+
+import (
+	"context"
+	"encoding/json"
+
+	"git.aiterp.net/rpdata/logbot3/internal/api"
+	"git.aiterp.net/rpdata/logbot3/internal/models"
+)
+
+type setLoggedResult struct {
+	EditChannel models.Channel `json:"editChannel"`
+}
+
+var setLoggedGQL = `
+	mutation SetChanelLogged($name: String!, $logged: Boolean!) {
+		editChannel(input: {name: $name, logged: $logged}) {
+			name
+			logged
+			eventName
+			locationName
+		}
+	}
+`
+
+// SetLogged sets a channel as logged
+func SetLogged(ctx context.Context, name string, logged bool) (models.Channel, error) {
+	data, err := api.Global().Query(ctx, setLoggedGQL, map[string]interface{}{"name": name, "logged": logged}, []string{"channel.edit"})
+	if err != nil {
+		return models.Channel{}, err
+	}
+
+	result := setLoggedResult{}
+	err = json.Unmarshal(data, &result)
+	if err != nil {
+		return models.Channel{}, err
+	}
+
+	return result.EditChannel, nil
+}

internal/models/channels/subscribe-logged.go

@@ -0,0 +1,30 @@
+package channels
+
+import (
+	"context"
+	"time"
+
+	"git.aiterp.net/rpdata/logbot3/internal/models"
+)
+
+// SubscribeLogged returns a channel that gets all the channel changes.
+func SubscribeLogged(ctx context.Context) (<-chan models.Channel, error) {
+	channels, err := ListLogged(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	output := make(chan models.Channel, len(channels)+8)
+	for _, channel := range channels {
+		output <- channel
+	}
+
+	go func() {
+		for {
+			time.Sleep(time.Second * 20)
+
+		}
+	}()
+
+	return output, nil
+}

internal/models/user.go

@@ -0,0 +1,26 @@
+package models
+
+// A User is the information about ID and permission for a user, usually
+// the caller.
+type User struct {
+	ID          string   `json:"id"`
+	Permissions []string `json:"permissions"`
+}
+
+// LoggedIn returns true if the user is logged-in.
+func (user *User) LoggedIn() bool {
+	return user.ID != ""
+}
+
+// Permitted gets whether the user has this permission.
+func (user *User) Permitted(permissions ...string) bool {
+	for _, userPermission := range user.Permissions {
+		for _, permission := range permissions {
+			if permission == userPermission {
+				return true
+			}
+		}
+	}
+
+	return false
+}

internal/models/users/check-token.go

@@ -0,0 +1,42 @@
+package users
+
+import (
+	"context"
+	"encoding/json"
+
+	"git.aiterp.net/rpdata/logbot3/internal/api"
+	"git.aiterp.net/rpdata/logbot3/internal/models"
+)
+
+type checkTokenResult struct {
+	Token struct {
+		User models.User `json:"user"`
+	} `json:"token"`
+}
+
+var checkTokenGQL = `
+	query CheckTokenQuery {
+		token {
+			user {
+				id
+				permissions
+			}
+		}
+	}
+`
+
+// CheckToken checks the own token and returns the user information.
+func CheckToken(ctx context.Context) (models.User, error) {
+	data, err := api.Global().Query(ctx, checkTokenGQL, nil, []string{"member"})
+	if err != nil {
+		return models.User{}, err
+	}
+
+	result := checkTokenResult{}
+	err = json.Unmarshal(data, &result)
+	if err != nil {
+		return models.User{}, err
+	}
+
+	return result.Token.User, nil
+}