models: Fixed earliestDate being exclusive of the earliest date in chnages.List.

.drone.yml

@@ -6,16 +6,16 @@ pipeline:
   docker-release:
     image: plugins/docker
     repo: vmaple/rpdata
-    tags: latest
     auto_tag: true
     secrets: [ docker_username, docker_password ]
     when:
       event: tag
       ref: refs/tags/*
-  docker-dev:
+  docker-release-latest:
     image: plugins/docker
     repo: vmaple/rpdata
-    tags: trunk
+    tags: latest
     secrets: [ docker_username, docker_password ]
     when:
-      event: push
+      event: tag
+      ref: refs/tags/*

.gitignore

@@ -1,7 +1,13 @@
 vendor
-schema/bindata.go
+graphql/schema/bindata.go
 config.json
 api
 debug
 build
-.vscode
+rpdata-graphiql
+rpdata-*
+!rpdata-*/
+.vscode
+
+generated.gql
+generated.go

Dockerfile

@@ -1,41 +1,29 @@
-## 1. Server
+## 1. Build Server
 # Use Go 1.10
-FROM golang:1.10 AS build-server
+FROM golang:1.11 AS build-server
 
 # Load repository into docker
 WORKDIR /go/src/git.aiterp.net/rpdata/api/
 COPY . .
+RUN rm -rf ./vendor
 
 # Load build tools and dependencies
 RUN go get -u github.com/golang/dep/cmd/dep
+RUN go get -u github.com/vektah/gorunpkg
 RUN go get -u github.com/jteeuwen/go-bindata/...
 RUN dep ensure
 RUN go generate ./...
 
 # Build server and tools (CGO disabled to make them 100% static)
 ENV CGO_ENABLED 0
-RUN go build -a -installsuffix cgo -ldflags="-s -w" -o /binaries/rpdata-graphiql ./cmd/rpdata-graphiql
+RUN go build -a -installsuffix cgo -ldflags="-s -w" -o /binaries/rpdata-server ./cmd/rpdata-server
 RUN go build -a -installsuffix cgo -ldflags="-s -w" -o /binaries/rpdata-lb2charimport ./cmd/rpdata-lb2charimport
 RUN go build -a -installsuffix cgo -ldflags="-s -w" -o /binaries/rpdata-lb2logimport ./cmd/rpdata-lb2logimport
-RUN go build -a -installsuffix cgo -ldflags="-s -w" -o /binaries/rpdata-wikifileimport ./cmd/rpdata-wikifileimport
+# TODO: RUN go build -a -installsuffix cgo -ldflags="-s -w" -o /binaries/rpdata-wikifileimport ./cmd/rpdata-wikifileimport
 RUN go build -a -installsuffix cgo -ldflags="-s -w" -o /binaries/rpdata-ensurechannels ./cmd/rpdata-ensurechannels
 RUN go build -a -installsuffix cgo -ldflags="-s -w" -o /binaries/rpdata-as2storyimport ./cmd/rpdata-as2storyimport
 
-## 2. React UI
-# Use Node.JS 18
-FROM node:10.5-alpine AS build-id
-
-# The content is already there
-WORKDIR /rpdata-ui
-COPY ./rpdata-ui /rpdata-ui
-
-# Prepare dependencies
-RUN npm install
-
-# Run build
-RUN npm run build
-
-## 3. Regroup
+## 2. Distribute
 # Use alpine linux
 FROM alpine:3.7
 
@@ -44,7 +32,6 @@ RUN apk add --no-cache ca-certificates
 
 # Copy build files into final container
 COPY --from=build-server /binaries/* /usr/local/bin/
-COPY --from=build-id /rpdata-ui/build /var/www/
 
-# TODO: Use proper server instead of grapihql server
-CMD ["/usr/local/bin/rpdata-graphiql"]
+# The server is the main entry point
+CMD ["/usr/local/bin/rpdata-server"]

Gopkg.lock

@@ -2,10 +2,32 @@
 
 
 [[projects]]
-  branch = "master"
-  name = "git.aiterp.net/aiterp/wikiauth"
+  name = "github.com/99designs/gqlgen"
+  packages = [
+    ".",
+    "cmd",
+    "codegen",
+    "codegen/templates",
+    "complexity",
+    "graphql",
+    "graphql/introspection",
+    "handler",
+    "internal/gopath"
+  ]
+  revision = "636435b68700211441303f1a5ed92f3768ba5774"
+  version = "v0.5.1"
+
+[[projects]]
+  name = "github.com/agnivade/levenshtein"
   packages = ["."]
-  revision = "33860de804ddcec4fc17998745233b4ec477e7c2"
+  revision = "3d21ba515fe27b856f230847e856431ae1724adc"
+  version = "v1.0.0"
+
+[[projects]]
+  name = "github.com/dgrijalva/jwt-go"
+  packages = ["."]
+  revision = "06ea1031745cb8b3dab3f6a236daf2b0aa468b7e"
+  version = "v3.2.0"
 
 [[projects]]
   branch = "master"
@@ -37,6 +59,12 @@
   revision = "d523deb1b23d913de5bdada721a6071e71283618"
   version = "v1.4.0"
 
+[[projects]]
+  name = "github.com/gorilla/websocket"
+  packages = ["."]
+  revision = "66b9c49e59c6c48f0ffce28c2d8b8a5678502c6d"
+  version = "v1.4.0"
+
 [[projects]]
   name = "github.com/graph-gophers/dataloader"
   packages = ["."]
@@ -64,6 +92,15 @@
   ]
   revision = "9ebf33af539ab8cb832c7107bc0a978ca8dbc0de"
 
+[[projects]]
+  name = "github.com/hashicorp/golang-lru"
+  packages = [
+    ".",
+    "simplelru"
+  ]
+  revision = "20f1fb78b0740ba8c3cb143a61e86ba5c8669768"
+  version = "v0.5.0"
+
 [[projects]]
   branch = "master"
   name = "github.com/jmoiron/sqlx"
@@ -103,10 +140,10 @@
   version = "v1.0.2"
 
 [[projects]]
-  name = "github.com/sadbox/mediawiki"
+  name = "github.com/pkg/errors"
   packages = ["."]
-  revision = "39fea8a1336076a961a300d1d95765dcd17e8a3c"
-  version = "v0.1"
+  revision = "645ef00459ed84a119197bfb8d8205042c6df63d"
+  version = "v0.8.0"
 
 [[projects]]
   name = "github.com/sirupsen/logrus"
@@ -114,6 +151,26 @@
   revision = "c155da19408a8799da419ed3eeb0cb5db0ad5dbc"
   version = "v1.0.5"
 
+[[projects]]
+  name = "github.com/urfave/cli"
+  packages = ["."]
+  revision = "cfb38830724cc34fedffe9a2a29fb54fa9169cd1"
+  version = "v1.20.0"
+
+[[projects]]
+  branch = "master"
+  name = "github.com/vektah/gqlparser"
+  packages = [
+    ".",
+    "ast",
+    "gqlerror",
+    "lexer",
+    "parser",
+    "validator",
+    "validator/rules"
+  ]
+  revision = "14e83ae06ec152e6d0afb9766a00e0c0918aa8fc"
+
 [[projects]]
   branch = "master"
   name = "golang.org/x/crypto"
@@ -164,15 +221,34 @@
   revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0"
   version = "v0.3.0"
 
+[[projects]]
+  branch = "master"
+  name = "golang.org/x/tools"
+  packages = [
+    "go/ast/astutil",
+    "go/buildutil",
+    "go/internal/cgo",
+    "go/loader",
+    "imports",
+    "internal/fastwalk"
+  ]
+  revision = "677d2ff680c188ddb7dcd2bfa6bc7d3f2f2f75b2"
+
 [[projects]]
   name = "google.golang.org/appengine"
   packages = ["cloudsql"]
   revision = "b1f26356af11148e710935ed1ac8a7f5702c7612"
   version = "v1.1.0"
 
+[[projects]]
+  name = "gopkg.in/yaml.v2"
+  packages = ["."]
+  revision = "5420a8b6744d3b0345ab293f6fcba19c978f1183"
+  version = "v2.2.1"
+
 [solve-meta]
   analyzer-name = "dep"
   analyzer-version = 1
-  inputs-digest = "16fd84401bc5796ffeaa895f31d099e1a23b363b15b87386877de0829ac9575b"
+  inputs-digest = "3c9430afa8b9260026925c8f496af934e2e573a2bd4587bb634fd12a20ce6c2c"
   solver-name = "gps-cdcl"
   solver-version = 1

Gopkg.toml

@@ -24,6 +24,8 @@
 #   go-tests = true
 #   unused-packages = true
 
+required = [ "github.com/99designs/gqlgen" ]
+
 [[constraint]]
   branch = "master"
   name = "github.com/globalsign/mgo"
@@ -38,4 +40,4 @@
 
 [[constraint]]
   branch = "master"
-  name = "github.com/graph-gophers/graphql-go"
+  name = "github.com/graph-gophers/graphql-go"

README.md

@@ -1,18 +1,5 @@
 # RPData API
 
-Project RPData aims to centralize the AiteRP applications, and partially involve the wiki, into a common API. This will allow for easy linking and inlining between them. The primary consumers of this API will be the Logbot and the upcoming RPData website.
+Project RPData aims to centralize the AiteRP applications, and partially involve the wiki into a common API. This will allow for easy linking and inlining between them. The primary consumers of this API will be the Logbot and the upcoming RPData website.
 
-## Progress
-
-### Complete
-* Session
-* Character
-* Log
-* Post
-* File
-
-### Remaining
-* Story
-
-### Future
-* User (manual DB edits will suffice for now)
+There is some renovation going on, and the packages `model` and `graphql` are going to be superceded by `models` and `graph2`

cmd/rpdata-as2storyimport/main.go

@@ -8,7 +8,9 @@ import (
 	"time"
 
 	"git.aiterp.net/rpdata/api/internal/store"
-	"git.aiterp.net/rpdata/api/model/story"
+	"git.aiterp.net/rpdata/api/models"
+	"git.aiterp.net/rpdata/api/models/chapters"
+	"git.aiterp.net/rpdata/api/models/stories"
 	_ "github.com/go-sql-driver/mysql"
 	"github.com/jmoiron/sqlx"
 )
@@ -71,14 +73,20 @@ func main() {
 			log.Fatalln(err)
 		}
 
-		tags := make([]story.Tag, 0, 8)
+		tags := make([]models.Tag, 0, 8)
 		for _, tagResult := range tagResults {
 			if tagResult.PageID == result.ID {
-				tags = append(tags, story.Tag{Kind: tagResult.Type, Name: tagResult.Name})
+				tags = append(tags, models.Tag{Kind: models.TagKind(tagResult.Type), Name: tagResult.Name})
 			}
 		}
 
-		story, err := story.New(result.Name, result.Author[5:], result.Category, false, false, tags, publishDate, fictionalDate)
+		category := models.StoryCategory(result.Category)
+		if !category.IsValid() {
+			log.Println(result.Name, "does not have a valid category:", result.Category)
+			continue
+		}
+
+		story, err := stories.Add(result.Name, result.Author[5:], category, true, false, tags, publishDate, fictionalDate)
 		if err != nil {
 			log.Fatalln(err)
 		}
@@ -96,19 +104,11 @@ func main() {
 			}
 		}
 
-		chapter, err := story.AddChapter(title, result.Author[5:], result.Source, publishDate, fictionalDate)
+		chapter, err := chapters.Add(story, title, result.Author[5:], result.Source, publishDate, &fictionalDate)
 		if err != nil {
 			log.Fatalln(err)
 		}
 
-		if !result.Unlisted {
-			listed := true
-			err := story.Edit(nil, nil, &listed, nil, nil)
-			if err != nil {
-				log.Fatalln(err)
-			}
-		}
-
 		fmt.Println(result.ID, "->", story.ID, chapter.ID)
 	}
 }

cmd/rpdata-ensurechannels/main.go

@@ -4,10 +4,9 @@ import (
 	"fmt"
 	"os"
 
-	"git.aiterp.net/rpdata/api/model/channel"
-
 	"git.aiterp.net/rpdata/api/internal/store"
-	"git.aiterp.net/rpdata/api/model/log"
+	"git.aiterp.net/rpdata/api/models/channels"
+	"git.aiterp.net/rpdata/api/models/logs"
 )
 
 func main() {
@@ -17,7 +16,7 @@ func main() {
 		return
 	}
 
-	logs, err := log.List(32768)
+	logs, err := logs.List(nil)
 	if err != nil {
 		fmt.Fprintln(os.Stderr, err)
 		return
@@ -25,18 +24,18 @@ func main() {
 
 	added := make(map[string]bool, 1024)
 	for _, log := range logs {
-		if added[log.Channel] {
+		if added[log.ChannelName] {
 			continue
 		}
 
-		_, err := channel.Ensure(log.Channel, false)
+		_, err := channels.Ensure(log.ChannelName, false)
 		if err != nil {
 			fmt.Fprintln(os.Stderr, log.ID, err)
 			continue
 		}
 
-		added[log.Channel] = true
+		added[log.ChannelName] = true
 
-		fmt.Println(log.Channel, "ensured")
+		fmt.Println(log.ChannelName, "ensured")
 	}
 }

cmd/rpdata-graphiql/.gitignore

@@ -1,2 +0,0 @@
-config.json
-debug

cmd/rpdata-graphiql/main.go

@@ -1,150 +0,0 @@
-package main
-
-import (
-	"context"
-	"encoding/json"
-	"log"
-	"net/http"
-
-	"git.aiterp.net/rpdata/api/graphql/loader"
-	"git.aiterp.net/rpdata/api/graphql/resolver"
-	"git.aiterp.net/rpdata/api/graphql/schema"
-	"git.aiterp.net/rpdata/api/internal/session"
-	"git.aiterp.net/rpdata/api/internal/store"
-	"git.aiterp.net/rpdata/api/model/change"
-	"git.aiterp.net/rpdata/api/model/file"
-	logModel "git.aiterp.net/rpdata/api/model/log"
-	graphql "github.com/graph-gophers/graphql-go"
-	"github.com/graph-gophers/graphql-go/relay"
-)
-
-func main() {
-	err := store.Init()
-	if err != nil {
-		log.Fatalln("Failed to init store:", err)
-	}
-
-	n, err := logModel.UpdateAllCharacters()
-	if err != nil {
-		log.Println("Charcter updated stopped:", err)
-	}
-	log.Println("Updated characters on", n, "logs")
-
-	schema, err := graphql.ParseSchema(schema.String(), &resolver.RootResolver{}, graphql.MaxParallelism(48))
-	if err != nil {
-		log.Fatalln("Failed to parse schema:", err)
-	}
-
-	http.Handle("/", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		if r.Method != "GET" {
-			http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
-			return
-		}
-
-		w.Write(page)
-	}))
-
-	relayHandler := &relay.Handler{Schema: schema}
-	http.HandleFunc("/graphql", func(w http.ResponseWriter, r *http.Request) {
-		r = session.Load(w, r)
-
-		l := loader.New()
-		r = r.WithContext(l.ToContext(r.Context()))
-
-		relayHandler.ServeHTTP(w, r)
-	})
-
-	http.HandleFunc("/upload", func(w http.ResponseWriter, r *http.Request) {
-		r = session.Load(w, r)
-		sess := session.FromContext(r.Context())
-		user := sess.User()
-		if user == nil || !user.Permitted("file.upload") {
-			http.Error(w, "Unauthorized", http.StatusUnauthorized)
-			return
-		}
-
-		if err := r.ParseMultipartForm(16384); err != nil {
-			http.Error(w, "Internal (1): "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		formFile, header, err := r.FormFile("file")
-		if err != nil || header == nil || formFile == nil {
-			http.Error(w, "No file provided", http.StatusBadRequest)
-			return
-		}
-
-		file, err := file.Upload(r.Context(), header.Filename, header.Header.Get("Content-Type"), user.ID, header.Size, formFile)
-		if err != nil {
-			http.Error(w, "Internal (2): "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		json, err := json.Marshal(file)
-		if err != nil {
-			http.Error(w, "Internal (3): "+err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		w.Header().Set("Content-Type", "application/json")
-		w.WriteHeader(http.StatusOK)
-		w.Write(json)
-	})
-
-	change.InitializeTimeline()
-	go func() {
-		index := int64(0)
-
-		for {
-			index++
-			ch, err := change.Timeline.Get(context.Background(), index)
-			if err == change.ErrExpired {
-				continue
-			} else if err != nil {
-				log.Println("Timeline:", err)
-				break
-			}
-
-			log.Printf("Change: time=%s model=%s op=%s id=%s author=%s\n", ch.Time.Local().Format("[Mon Jan 02 15:04 MST]"), ch.Model, ch.Op, ch.ObjectID, ch.Author)
-		}
-	}()
-
-	log.Fatal(http.ListenAndServe(":17000", nil))
-}
-
-var page = []byte(`
-	<!DOCTYPE html>
-	<html>
-		<head>
-			<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/graphiql/0.10.2/graphiql.css" />
-			<script src="https://cdnjs.cloudflare.com/ajax/libs/fetch/1.1.0/fetch.min.js"></script>
-			<script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.5.4/react.min.js"></script>
-			<script src="https://cdnjs.cloudflare.com/ajax/libs/react/15.5.4/react-dom.min.js"></script>
-			<script src="https://cdnjs.cloudflare.com/ajax/libs/graphiql/0.10.2/graphiql.js"></script>
-		</head>
-		<body style="width: 100%; height: 100%; margin: 0; overflow: hidden;">
-			<div id="graphiql" style="height: 100vh;">Loading...</div>
-			<script>
-				function graphQLFetcher(graphQLParams) {
-					return fetch("/graphql", {
-						method: "post",
-						body: JSON.stringify(graphQLParams),
-						credentials: "include",
-					}).then(function (response) {
-						return response.text();
-					}).then(function (responseBody) {
-						try {
-							return JSON.parse(responseBody);
-						} catch (error) {
-							return responseBody;
-						}
-					});
-				}
-				ReactDOM.render(
-					React.createElement(GraphiQL, {fetcher: graphQLFetcher}),
-					document.getElementById("graphiql")
-				);
-			</script>
-		</body>
-	</html>
-	`)

cmd/rpdata-lb2charimport/main.go

@@ -6,7 +6,7 @@ import (
 	"os"
 
 	"git.aiterp.net/rpdata/api/internal/store"
-	"git.aiterp.net/rpdata/api/model/character"
+	"git.aiterp.net/rpdata/api/models/characters"
 )
 
 var fileName = flag.String("file", "./characters.json", "json file to load")
@@ -31,12 +31,12 @@ func main() {
 	nicksAdded, nicksFailed := 0, 0
 
 	for _, info := range infos {
-		char, err := character.New(info.Nicks[0], info.Name, info.ShortName, info.Author, "")
+		char, err := characters.Add(info.Nicks[0], info.Name, info.ShortName, info.Author, "")
 		if err != nil {
 			log.Println(info.Nicks[0], "failed to insert:", err)
 			charsFailed++
 
-			char, err = character.FindNick(info.Nicks[0])
+			char, err = characters.FindNick(info.Nicks[0])
 			if err != nil {
 				continue
 			}
@@ -46,7 +46,7 @@ func main() {
 		}
 
 		for _, alt := range info.Nicks[1:] {
-			err := char.AddNick(alt)
+			char, err = characters.AddNick(char, alt)
 			if err != nil {
 				log.Println(info.Nicks[0], "failed to add nick", alt, "error:", err)
 				nicksFailed++

cmd/rpdata-lb2logimport/main.go

@@ -8,8 +8,10 @@ import (
 	"strings"
 	"time"
 
+	"git.aiterp.net/rpdata/api/models/posts"
+
 	"git.aiterp.net/rpdata/api/internal/store"
-	logModel "git.aiterp.net/rpdata/api/model/log"
+	"git.aiterp.net/rpdata/api/models/logs"
 )
 
 var prefixReplacer = strings.NewReplacer("+", "", "@", "", "!", "", "%", "")
@@ -47,13 +49,13 @@ func main() {
 			log.Fatalln(err)
 		}
 
-		l, err := logModel.New(date, channel, title, event, "", false)
+		l, err := logs.Add(date, channel, title, event, "", false)
 		if err != nil {
 			log.Println(err)
 			continue
 		}
 
-		_, err = l.NewPost(time.Now(), "annotation.info", "rpdata-lb2logimport", "This logfile is imported from aitelogs2 and may contain errors or wrong timestamps.")
+		_, err = posts.Add(l, time.Now(), "annotation.info", "rpdata-lb2logimport", "This logfile is imported from aitelogs2 and may contain errors or wrong timestamps.")
 		if err != nil {
 			log.Println(err)
 		}
@@ -63,7 +65,7 @@ func main() {
 				continue
 			}
 
-			_, err = l.NewPost(l.Date, "chars", prefixReplacer.Replace(line.Args[0]), line.Text)
+			_, err = posts.Add(l, l.Date, "chars", prefixReplacer.Replace(line.Args[0]), line.Text)
 			if err != nil {
 				log.Println(err)
 			}
@@ -92,13 +94,13 @@ func main() {
 				line.Verb = "SCENE"
 			}
 
-			_, err = l.NewPost(postTime, strings.ToLower(line.Verb), prefixReplacer.Replace(line.Args[0]), line.Text)
+			_, err = posts.Add(l, postTime, strings.ToLower(line.Verb), prefixReplacer.Replace(line.Args[0]), line.Text)
 			if err != nil {
 				log.Println(err)
 			}
 		}
 
-		err = l.UpdateCharacters()
+		l, err = logs.UpdateCharacters(l)
 		if err != nil {
 			log.Println(err)
 		}

cmd/rpdata-server/main.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net/http"
+	"runtime/debug"
+	"strings"
+
+	"git.aiterp.net/rpdata/api/models/logs"
+
+	"git.aiterp.net/rpdata/api/graph2"
+	"git.aiterp.net/rpdata/api/internal/auth"
+	"git.aiterp.net/rpdata/api/internal/loader"
+	"git.aiterp.net/rpdata/api/internal/store"
+	"github.com/99designs/gqlgen/handler"
+)
+
+func main() {
+	err := store.Init()
+	if err != nil {
+		log.Fatalln("Failed to init store:", err)
+	}
+
+	http.Handle("/", handler.Playground("RPData API", "/graphql"))
+	http.Handle("/graphql", queryHandler())
+
+	go func() {
+		err := logs.RunFullUpdate()
+		if err != nil {
+			log.Println(err)
+		}
+
+		log.Println("Characters updated")
+	}()
+
+	log.Fatal(http.ListenAndServe(":8081", nil))
+}
+
+func queryHandler() http.HandlerFunc {
+	handler := handler.GraphQL(
+		graph2.New(),
+		handler.RecoverFunc(func(ctx context.Context, err interface{}) error {
+			// send this panic somewhere
+			log.Println(err)
+			log.Println(string(debug.Stack()))
+
+			return fmt.Errorf("shit")
+		}),
+	)
+
+	return func(w http.ResponseWriter, r *http.Request) {
+		l := loader.New()
+		r = r.WithContext(l.ToContext(r.Context()))
+
+		// >_>
+		if strings.HasPrefix(r.Header.Get("Authorization"), "Bearer of the curse") {
+			w.Header().Set("X-Emerald-Herald", "Seek souls. Larger, more powerful souls.")
+			w.Header().Add("X-Emerald-Herald", "Seek the king, that is the only way.")
+			w.Header().Add("X-Emerald-Herald", "Lest this land swallow you whole... As it has so many others.")
+		}
+
+		r = auth.RequestWithToken(r)
+
+		handler.ServeHTTP(w, r)
+	}
+}

cmd/rpdata-wikifileimport/main.go

@@ -9,7 +9,7 @@ import (
 
 	"git.aiterp.net/rpdata/api/internal/config"
 	"git.aiterp.net/rpdata/api/internal/store"
-	"git.aiterp.net/rpdata/api/model/file"
+	"git.aiterp.net/rpdata/api/models/files"
 )
 
 func main() {
@@ -33,7 +33,7 @@ func main() {
 	store.Init()
 
 	for _, info := range data.Query.Allimages {
-		existing, err := file.FindName("wiki", info.Name, info.User)
+		existing, err := files.FindName("wiki", info.Name, info.User)
 		if err == nil && existing.ID != "" {
 			log.Println("Skipping", info.Name, "because it already exists")
 			continue
@@ -45,7 +45,7 @@ func main() {
 			continue
 		}
 
-		file, err := file.Insert(info.Name, "wiki", info.Mime, info.User, ts, info.Size, info.URL)
+		file, err := files.Insert(info.Name, "wiki", info.Mime, info.User, ts, info.Size, info.URL)
 		if err != nil {
 			log.Println("Skipping", info.Name, "error:", err)
 			continue

graph2/combine.sh

@@ -0,0 +1,4 @@
+#!/bin/sh
+
+echo "# Generated by stiching together the files under schema/ – DO NOT EDIT" >generated.gql
+cat schema/root.gql schema/**/*.gql >>generated.gql

graph2/gqlgen.yml

@@ -0,0 +1,67 @@
+schema: generated.gql
+
+exec:
+  filename: generated.go
+  package: graph2
+
+model:
+  filename: input/generated.go
+  package: input
+
+models:
+  Tag:
+    model: git.aiterp.net/rpdata/api/models.Tag
+  TagInput: #It's the same as tags
+    model: git.aiterp.net/rpdata/api/models.Tag
+  TagKind:
+    model: git.aiterp.net/rpdata/api/models.TagKind
+  Character:
+    model: git.aiterp.net/rpdata/api/models.Character
+  CharactersFilter:
+    model: git.aiterp.net/rpdata/api/models/characters.Filter
+  Channel:
+    model: git.aiterp.net/rpdata/api/models.Channel
+  ChannelsFilter:
+    model: git.aiterp.net/rpdata/api/models/channels.Filter
+  Post:
+    model: git.aiterp.net/rpdata/api/models.Post
+  PostsFilter:
+    model: git.aiterp.net/rpdata/api/models/posts.Filter
+  Log:
+    model: git.aiterp.net/rpdata/api/models.Log
+  LogsFilter:
+    model: git.aiterp.net/rpdata/api/models/logs.Filter
+  Chapter:
+    model: git.aiterp.net/rpdata/api/models.Chapter
+    fields:
+      fictionalDate:
+        resolver: true
+  Story:
+    model: git.aiterp.net/rpdata/api/models.Story
+    fields:
+      fictionalDate:
+        resolver: true
+  StoryCategory:
+    model: git.aiterp.net/rpdata/api/models.StoryCategory
+  StoriesFilter:
+    model: git.aiterp.net/rpdata/api/models/stories.Filter
+  File:
+    model: git.aiterp.net/rpdata/api/models.File
+  FilesFilter:
+    model: git.aiterp.net/rpdata/api/models/files.Filter
+  Change:
+    model: git.aiterp.net/rpdata/api/models.Change
+  ChangeModel:
+    model: git.aiterp.net/rpdata/api/models.ChangeModel
+  ChangeKey:
+    model: git.aiterp.net/rpdata/api/models.ChangeKey
+  ChangeKeyInput: # It's the same as ChangeKey
+    model: git.aiterp.net/rpdata/api/models.ChangeKey
+  ChangesFilter:
+    model: git.aiterp.net/rpdata/api/models/changes.Filter
+  Token:
+    model: git.aiterp.net/rpdata/api/models.Token
+  User:
+    model: git.aiterp.net/rpdata/api/models.User
+  Date:
+    model: git.aiterp.net/rpdata/api/models/scalars.Date

graph2/graph.go

@@ -0,0 +1,51 @@
+package graph2
+
+import (
+	"git.aiterp.net/rpdata/api/graph2/queries"
+	"git.aiterp.net/rpdata/api/graph2/types"
+	graphql "github.com/99designs/gqlgen/graphql"
+)
+
+//go:generate ./combine.sh
+//go:generate gorunpkg github.com/99designs/gqlgen -v
+
+// New creates a new GraphQL schema.
+func New() graphql.ExecutableSchema {
+	return NewExecutableSchema(Config{
+		Resolvers: &rootResolver{},
+	})
+}
+
+type rootResolver struct{}
+
+func (r *rootResolver) Query() QueryResolver {
+	return &queries.Resolver
+}
+
+func (r *rootResolver) Mutation() MutationResolver {
+	return queries.MutationResolver
+}
+
+func (r *rootResolver) Log() LogResolver {
+	return &types.LogResolver
+}
+
+func (r *rootResolver) Chapter() ChapterResolver {
+	return &types.ChapterResolver
+}
+
+func (r *rootResolver) Story() StoryResolver {
+	return &types.StoryResolver
+}
+
+func (r *rootResolver) File() FileResolver {
+	return &types.FileResolver
+}
+
+func (r *rootResolver) Change() ChangeResolver {
+	return &types.ChangeResolver
+}
+
+func (r *rootResolver) Token() TokenResolver {
+	return &types.TokenResolver
+}

graph2/queries/changes.go

@@ -0,0 +1,14 @@
+package queries
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/models"
+	"git.aiterp.net/rpdata/api/models/changes"
+)
+
+/// Queries
+
+func (r *resolver) Changes(ctx context.Context, filter *changes.Filter) ([]models.Change, error) {
+	return changes.List(filter)
+}

graph2/queries/channel.go

@@ -0,0 +1,79 @@
+package queries
+
+import (
+	"context"
+	"errors"
+
+	"git.aiterp.net/rpdata/api/graph2/input"
+	"git.aiterp.net/rpdata/api/internal/auth"
+	"git.aiterp.net/rpdata/api/models"
+	"git.aiterp.net/rpdata/api/models/changekeys"
+	"git.aiterp.net/rpdata/api/models/changes"
+	"git.aiterp.net/rpdata/api/models/channels"
+)
+
+// Queries
+
+func (r *resolver) Channel(ctx context.Context, name string) (models.Channel, error) {
+	return channels.FindName(name)
+}
+
+func (r *resolver) Channels(ctx context.Context, filter *channels.Filter) ([]models.Channel, error) {
+	return channels.List(filter)
+}
+
+// Mutations
+
+func (r *mutationResolver) AddChannel(ctx context.Context, input input.ChannelAddInput) (models.Channel, error) {
+	token := auth.TokenFromContext(ctx)
+	if !token.Authenticated() || !token.Permitted("channel.add") {
+		return models.Channel{}, errors.New("You are not permitted to add channels")
+	}
+
+	logged := false
+	if input.Logged != nil {
+		logged = *input.Logged
+	}
+	hub := false
+	if input.Hub != nil {
+		hub = *input.Hub
+	}
+	eventName := ""
+	if input.EventName != nil {
+		eventName = *input.EventName
+	}
+	locationName := ""
+	if input.LocationName != nil {
+		locationName = *input.LocationName
+	}
+
+	channel, err := channels.Add(input.Name, logged, hub, eventName, locationName)
+	if err != nil {
+		return models.Channel{}, errors.New("Failed to add channel: " + err.Error())
+	}
+
+	go changes.Submit("Channel", "add", token.UserID, true, changekeys.Listed(channel), channel)
+
+	return channel, nil
+}
+
+func (r *mutationResolver) EditChannel(ctx context.Context, input input.ChannelEditInput) (models.Channel, error) {
+	token := auth.TokenFromContext(ctx)
+	if !token.Authenticated() || !token.Permitted("channel.edit") {
+		return models.Channel{}, errors.New("You are not permitted to edit channels")
+	}
+
+	channel, err := channels.FindName(input.Name)
+	if err != nil {
+		return models.Channel{}, errors.New("Channel not found")
+	}
+
+	channel, err = channels.Edit(channel, input.Logged, input.Hub, input.EventName, input.LocationName)
+	if err != nil {
+		return models.Channel{}, errors.New("Failed to edit channel: " + err.Error())
+	}
+
+	go changes.Submit("Channel", "edit", token.UserID, true, changekeys.Listed(channel), channel)
+
+	return channel, nil
+}

graph2/queries/chapter.go

@@ -0,0 +1,163 @@
+package queries
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"git.aiterp.net/rpdata/api/models/changekeys"
+	"git.aiterp.net/rpdata/api/models/changes"
+
+	"git.aiterp.net/rpdata/api/internal/auth"
+	"git.aiterp.net/rpdata/api/models/stories"
+
+	"git.aiterp.net/rpdata/api/graph2/input"
+	"git.aiterp.net/rpdata/api/models"
+	"git.aiterp.net/rpdata/api/models/chapters"
+)
+
+// Queries
+
+func (r *resolver) Chapter(ctx context.Context, id string) (models.Chapter, error) {
+	return chapters.FindID(id)
+}
+
+// Mutations
+
+func (r *mutationResolver) AddChapter(ctx context.Context, input input.ChapterAddInput) (models.Chapter, error) {
+	story, err := stories.FindID(input.StoryID)
+	if err != nil {
+		return models.Chapter{}, errors.New("Story not found")
+	}
+
+	token := auth.TokenFromContext(ctx)
+	if !token.Permitted("member", "story.add") {
+		return models.Chapter{}, errors.New("Unauthorized")
+	}
+
+	author := token.UserID
+	if input.Author != nil && *input.Author != author {
+		if !token.Permitted("story.add") {
+			return models.Chapter{}, errors.New("False pretender")
+		}
+
+		author = *input.Author
+	}
+
+	if !story.Open && story.Author != author {
+		return models.Chapter{}, errors.New("Story is not open")
+	}
+
+	chapter, err := chapters.Add(story, input.Title, author, input.Source, time.Now(), input.FictionalDate)
+	if err != nil {
+		return models.Chapter{}, errors.New("Failed to create chapter: " + err.Error())
+	}
+
+	go changes.Submit("Chapter", "add", token.UserID, story.Listed, changekeys.Listed(story, chapter), story, chapter)
+
+	return chapter, nil
+}
+
+func (r *mutationResolver) MoveChapter(ctx context.Context, input input.ChapterMoveInput) (models.Chapter, error) {
+	chapter, err := chapters.FindID(input.ID)
+	if err != nil {
+		return models.Chapter{}, errors.New("Chapter not found")
+	}
+
+	token := auth.TokenFromContext(ctx)
+	if !token.Authenticated() || !token.PermittedUser(chapter.Author, "member", "chapter.move") {
+		return models.Chapter{}, errors.New("You are not allowed to move this chapter")
+	}
+
+	target, err := stories.FindID(input.StoryID)
+	if err != nil {
+		return models.Chapter{}, errors.New("Target story not found")
+	}
+
+	if !target.Open && !token.PermittedUser(target.Author, "member", "chapter.move") {
+		return models.Chapter{}, errors.New("You are not permitted to move chapters to this story")
+	}
+
+	oldStoryID := chapter.StoryID
+	chapter, err = chapters.Move(chapter, target)
+	if err != nil {
+		return models.Chapter{}, errors.New("Failed to move chapter: " + err.Error())
+	}
+
+	go func() {
+		story, err := stories.FindID(chapter.StoryID)
+		if err != nil {
+			story.ID = chapter.StoryID
+		}
+
+		oldStory, err := stories.FindID(oldStoryID)
+		if err != nil {
+			oldStory.ID = oldStoryID
+		}
+
+		changes.Submit("Chapter", "move-out", chapter.Author, oldStory.Listed, changekeys.Many(oldStory, chapter), chapter)
+		changes.Submit("Chapter", "move-in", token.UserID, story.Listed, changekeys.Listed(story, chapter), story, chapter)
+	}()
+
+	return chapter, nil
+}
+
+func (r *mutationResolver) EditChapter(ctx context.Context, input input.ChapterEditInput) (models.Chapter, error) {
+	chapter, err := chapters.FindID(input.ID)
+	if err != nil {
+		return models.Chapter{}, errors.New("Chapter not found")
+	}
+
+	token := auth.TokenFromContext(ctx)
+	if !token.Authenticated() || !token.PermittedUser(chapter.Author, "member", "chapter.edit") {
+		return models.Chapter{}, errors.New("Unauthorized")
+	}
+
+	if input.ClearFictionalDate != nil && *input.ClearFictionalDate == true {
+		input.FictionalDate = &time.Time{}
+	}
+
+	chapter, err = chapters.Edit(chapter, input.Title, input.Source, input.FictionalDate)
+	if err != nil {
+		return models.Chapter{}, errors.New("Failed to edit chapter: " + err.Error())
+	}
+
+	go func() {
+		story, err := stories.FindID(chapter.StoryID)
+		if err != nil {
+			story.ID = chapter.StoryID
+		}
+
+		changes.Submit("Chapter", "edit", token.UserID, story.Listed, changekeys.Many(story, chapter), chapter)
+	}()
+
+	return chapter, nil
+}
+
+func (r *mutationResolver) RemoveChapter(ctx context.Context, input input.ChapterRemoveInput) (models.Chapter, error) {
+	chapter, err := chapters.FindID(input.ID)
+	if err != nil {
+		return models.Chapter{}, errors.New("Chapter not found")
+	}
+
+	token := auth.TokenFromContext(ctx)
+	if !token.Authenticated() || !token.PermittedUser(chapter.Author, "member", "chapter.remove") {
+		return models.Chapter{}, errors.New("Unauthorized")
+	}
+
+	chapter, err = chapters.Remove(chapter)
+	if err != nil {
+		return models.Chapter{}, errors.New("Failed to remove chapter: " + err.Error())
+	}
+
+	go func() {
+		story, err := stories.FindID(chapter.StoryID)
+		if err != nil {
+			story.ID = chapter.StoryID
+		}
+
+		changes.Submit("Chapter", "remove", token.UserID, story.Listed, changekeys.Many(story, chapter), chapter)
+	}()
+
+	return chapter, nil
+}

graph2/queries/character.go

@@ -0,0 +1,174 @@
+package queries
+
+import (
+	"context"
+	"errors"
+	"strings"
+
+	"git.aiterp.net/rpdata/api/graph2/input"
+	"git.aiterp.net/rpdata/api/internal/auth"
+	"git.aiterp.net/rpdata/api/models"
+	"git.aiterp.net/rpdata/api/models/changekeys"
+	"git.aiterp.net/rpdata/api/models/changes"
+	"git.aiterp.net/rpdata/api/models/characters"
+	"git.aiterp.net/rpdata/api/models/logs"
+)
+
+// Queries
+
+func (r *resolver) Character(ctx context.Context, id *string, nick *string) (models.Character, error) {
+	if id != nil {
+		return characters.FindID(*id)
+	} else if nick != nil {
+		return characters.FindNick(*nick)
+	} else {
+		return models.Character{}, errors.New("You must specify either an ID or a nick")
+	}
+}
+
+func (r *resolver) Characters(ctx context.Context, filter *characters.Filter) ([]models.Character, error) {
+	return characters.List(filter)
+}
+
+// Mutations
+
+func (r *mutationResolver) AddCharacter(ctx context.Context, input input.CharacterAddInput) (models.Character, error) {
+	token := auth.TokenFromContext(ctx)
+	if !token.Permitted("member", "character.add") {
+		return models.Character{}, errors.New("You are not permitted to add characters")
+	}
+	if len(input.Name) < 2 || len(input.Nick) < 2 {
+		return models.Character{}, errors.New("You need to provide a name and a nick (min length: 2)")
+	}
+
+	shortName := ""
+	if input.ShortName != nil {
+		shortName = *input.ShortName
+	} else {
+		shortName = strings.SplitN(input.Name, " ", 2)[0]
+	}
+
+	description := ""
+	if input.Description != nil {
+		description = *input.Description
+	}
+
+	author := token.UserID
+	if input.Author != nil && *input.Author != author {
+		if !token.Permitted("character.add") {
+			return models.Character{}, errors.New("You are only permitted to add your own characters")
+		}
+
+		author = *input.Author
+	}
+
+	logs.ScheduleFullUpdate()
+
+	character, err := characters.Add(input.Nick, input.Name, shortName, author, description)
+	if err != nil {
+		return models.Character{}, errors.New("Adding character failed: " + err.Error())
+	}
+
+	go changes.Submit("Character", "add", token.UserID, true, changekeys.Listed(character), character)
+
+	return character, nil
+}
+
+func (r *mutationResolver) AddCharacterNick(ctx context.Context, input input.CharacterNickInput) (models.Character, error) {
+	character, err := characters.FindID(input.ID)
+	if err != nil {
+		return models.Character{}, errors.New("Character not found")
+	}
+
+	if len(input.Nick) < 2 {
+		return models.Character{}, errors.New("You need to provide a valid nick (min length: 2)")
+	}
+
+	token := auth.TokenFromContext(ctx)
+	if !token.PermittedUser(character.Author, "member", "character.edit") {
+		return models.Character{}, errors.New("You are not permitted to edit this character")
+	}
+
+	logs.ScheduleFullUpdate()
+
+	character, err = characters.AddNick(character, input.Nick)
+	if err != nil {
+		return models.Character{}, errors.New("Failed to add nick: " + err.Error())
+	}
+
+	go logs.ScheduleFullUpdate()
+	go changes.Submit("Character", "edit", token.UserID, true, changekeys.Listed(character), character)
+
+	return character, nil
+}
+
+func (r *mutationResolver) RemoveCharacterNick(ctx context.Context, input input.CharacterNickInput) (models.Character, error) {
+	character, err := characters.FindID(input.ID)
+	if err != nil {
+		return models.Character{}, errors.New("Character not found")
+	}
+
+	token := auth.TokenFromContext(ctx)
+	if !token.PermittedUser(character.Author, "member", "character.edit") {
+		return models.Character{}, errors.New("You are not permitted to edit this character")
+	}
+
+	character, err = characters.RemoveNick(character, input.Nick)
+	if err != nil {
+		return models.Character{}, errors.New("Failed to remove nick: " + err.Error())
+	}
+
+	go logs.ScheduleFullUpdate()
+	go changes.Submit("Character", "edit", token.UserID, true, changekeys.Listed(character), character)
+
+	return character, nil
+}
+
+func (r *mutationResolver) EditCharacter(ctx context.Context, input input.CharacterEditInput) (models.Character, error) {
+	character, err := characters.FindID(input.ID)
+	if err != nil {
+		return models.Character{}, errors.New("Character not found")
+	}
+
+	if input.Name != nil && len(*input.Name) < 2 {
+		return models.Character{}, errors.New("You need to provide a valid name (min length: 2)")
+	}
+	if input.ShortName != nil && len(*input.ShortName) < 2 {
+		return models.Character{}, errors.New("You need to provide a valid short name (min length: 2)")
+	}
+
+	token := auth.TokenFromContext(ctx)
+	if !token.PermittedUser(character.Author, "member", "character.edit") {
+		return models.Character{}, errors.New("You are not permitted to edit this character")
+	}
+
+	character, err = characters.Edit(character, input.Name, input.ShortName, input.Description)
+	if err != nil {
+		return models.Character{}, errors.New("Failed to edit character: " + err.Error())
+	}
+
+	go changes.Submit("Character", "edit", token.UserID, true, changekeys.Listed(character), character)
+
+	return character, nil
+}
+
+func (r *mutationResolver) RemoveCharacter(ctx context.Context, input input.CharacterRemoveInput) (models.Character, error) {
+	character, err := characters.FindID(input.ID)
+	if err != nil {
+		return models.Character{}, errors.New("Character not found")
+	}
+
+	token := auth.TokenFromContext(ctx)
+	if !token.PermittedUser(character.Author, "member", "character.remove") {
+		return models.Character{}, errors.New("You are not permitted to remove this character")
+	}
+
+	character, err = characters.Remove(character)
+	if err != nil {
+		return models.Character{}, errors.New("Failed to remove character: " + err.Error())
+	}
+
+	go changes.Submit("Character", "remove", token.UserID, true, changekeys.Listed(character), character)
+
+	return character, nil
+}

graph2/queries/file.go

@@ -0,0 +1,34 @@
+package queries
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/internal/auth"
+	"git.aiterp.net/rpdata/api/models"
+	"git.aiterp.net/rpdata/api/models/files"
+)
+
+func (r *resolver) File(ctx context.Context, id string) (models.File, error) {
+	return files.FindID(id)
+}
+
+func (r *resolver) Files(ctx context.Context, filter *files.Filter) ([]models.File, error) {
+	token := auth.TokenFromContext(ctx)
+
+	if filter == nil {
+		filter = &files.Filter{}
+	}
+
+	// Only allow users to view public files that are not their own.
+	if token != nil {
+		if filter.Public == nil || *filter.Public == false {
+			filter.Author = &token.UserID
+		}
+	} else {
+		filter.Public = &trueValue
+	}
+
+	return files.List(filter)
+}
+
+var trueValue = true

graph2/queries/log.go

@@ -0,0 +1,139 @@
+package queries
+
+import (
+	"context"
+	"errors"
+	"strings"
+
+	"git.aiterp.net/rpdata/api/models/channels"
+
+	"git.aiterp.net/rpdata/api/graph2/input"
+	"git.aiterp.net/rpdata/api/internal/auth"
+	"git.aiterp.net/rpdata/api/internal/loader"
+	"git.aiterp.net/rpdata/api/models"
+	"git.aiterp.net/rpdata/api/models/changekeys"
+	"git.aiterp.net/rpdata/api/models/changes"
+	"git.aiterp.net/rpdata/api/models/logs"
+	"github.com/99designs/gqlgen/graphql"
+)
+
+// Queries
+
+func (r *resolver) Log(ctx context.Context, id string) (models.Log, error) {
+	return logs.FindID(id)
+}
+
+func (r *resolver) Logs(ctx context.Context, filter *logs.Filter) ([]models.Log, error) {
+	logs, err := logs.List(filter)
+	if err != nil {
+		return nil, err
+	}
+
+	reqCtx := graphql.GetRequestContext(ctx)
+	maybeCharacters := strings.Contains(reqCtx.RawQuery, "characters")
+	maybeChannels := strings.Contains(reqCtx.RawQuery, "channels")
+
+	if len(logs) >= 100 && (maybeCharacters || maybeChannels) {
+		loader := loader.FromContext(ctx)
+		if loader == nil {
+			return nil, errors.New("no loader")
+		}
+
+		for _, log := range logs {
+			if maybeChannels {
+				loader.PrimeChannels("name", log.ChannelName)
+			}
+
+			if maybeCharacters {
+				loader.PrimeCharacters("id", log.CharacterIDs...)
+			}
+		}
+	}
+
+	return logs, nil
+}
+
+// Mutations
+
+func (r *mutationResolver) AddLog(ctx context.Context, input input.LogAddInput) (models.Log, error) {
+	token := auth.TokenFromContext(ctx)
+	if !token.Authenticated() || !token.Permitted("log.add") {
+		return models.Log{}, errors.New("You are not permitted to add logs")
+	}
+
+	open := input.Open != nil && *input.Open == true
+	title := ""
+	if input.Title != nil {
+		title = *input.Title
+	}
+	event := ""
+	if input.Event != nil {
+		event = *input.Event
+	}
+	description := ""
+	if input.Description != nil {
+		description = *input.Description
+	}
+
+	existingChannel, _ := channels.FindName(input.Channel)
+
+	log, err := logs.Add(input.Date, input.Channel, title, event, description, open)
+	if !token.Authenticated() || !token.Permitted("log.add") {
+		return models.Log{}, errors.New("Failed to create log: " + err.Error())
+	}
+
+	go func() {
+		if existingChannel.Name == "" {
+			channel, err := channels.FindName(input.Channel)
+			if err == nil {
+				changes.Submit("Channel", "add", token.UserID, true, changekeys.Listed(channel), channel)
+			}
+		}
+
+		changes.Submit("Log", "add", token.UserID, true, changekeys.Listed(log), log)
+	}()
+
+	return log, nil
+}
+
+func (r *mutationResolver) EditLog(ctx context.Context, input input.LogEditInput) (models.Log, error) {
+	token := auth.TokenFromContext(ctx)
+	if !token.Authenticated() || !token.Permitted("log.edit") {
+		return models.Log{}, errors.New("You are not permitted to edit logs")
+	}
+
+	log, err := logs.FindID(input.ID)
+	if err != nil {
+		return models.Log{}, errors.New("Log not found")
+	}
+
+	log, err = logs.Edit(log, input.Title, input.Event, input.Description, input.Open)
+	if err != nil {
+		return models.Log{}, errors.New("Failed to edit log: " + err.Error())
+	}
+
+	go changes.Submit("Log", "edit", token.UserID, true, changekeys.Listed(log), log)
+
+	return log, nil
+}
+
+func (r *mutationResolver) RemoveLog(ctx context.Context, input input.LogRemoveInput) (models.Log, error) {
+	token := auth.TokenFromContext(ctx)
+	if !token.Authenticated() || !token.Permitted("log.remove") {
+		return models.Log{}, errors.New("You are not permitted to remove logs")
+	}
+
+	log, err := logs.FindID(input.ID)
+	if err != nil {
+		return models.Log{}, errors.New("Log not found")
+	}
+
+	log, err = logs.Remove(log)
+	if err != nil {
+		return models.Log{}, errors.New("Failed to remove log: " + err.Error())
+	}
+
+	go changes.Submit("Log", "remove", token.UserID, true, changekeys.Listed(log), log)
+
+	return log, nil
+}

graph2/queries/post.go

@@ -0,0 +1,162 @@
+package queries
+
+import (
+	"context"
+	"errors"
+
+	"git.aiterp.net/rpdata/api/models/changekeys"
+	"git.aiterp.net/rpdata/api/models/changes"
+	"git.aiterp.net/rpdata/api/models/logs"
+
+	"git.aiterp.net/rpdata/api/graph2/input"
+	"git.aiterp.net/rpdata/api/internal/auth"
+	"git.aiterp.net/rpdata/api/models"
+	"git.aiterp.net/rpdata/api/models/posts"
+)
+
+// Queries
+
+func (r *resolver) Post(ctx context.Context, id string) (models.Post, error) {
+	return posts.FindID(id)
+}
+
+func (r *resolver) Posts(ctx context.Context, filter *posts.Filter) ([]models.Post, error) {
+	// Some sanity checks to avoid querying an insame amount of posts.
+	if filter == nil {
+		filter = &posts.Filter{Limit: 256}
+	} else {
+		if (filter.Limit <= 0 || filter.Limit > 256) && filter.LogID == nil {
+			return nil, errors.New("a limit of 0 (no limit) or >256 without a logId is not allowed")
+		}
+
+		if len(filter.Kind) > 32 {
+			return nil, errors.New("You cannot specify more than 32 kinds")
+		}
+
+		if len(filter.ID) > 32 {
+			return nil, errors.New("You cannot specify more than 32 IDs")
+		}
+	}
+
+	return posts.List(filter)
+}
+
+// Mutation
+
+func (r *mutationResolver) AddPost(ctx context.Context, input input.PostAddInput) (models.Post, error) {
+	token := auth.TokenFromContext(ctx)
+	if !token.Authenticated() || !token.Permitted("post.add") {
+		return models.Post{}, errors.New("You are not permitted to edit logs")
+	}
+
+	log, err := logs.FindID(input.LogID)
+	if err != nil {
+		return models.Post{}, err
+	}
+
+	post, err := posts.Add(log, input.Time, input.Kind, input.Nick, input.Text)
+	if err != nil {
+		return models.Post{}, err
+	}
+
+	go logs.UpdateCharacters(log)
+	go changes.Submit("Post", "add", token.UserID, true, changekeys.Many(log, post), post)
+
+	return post, nil
+}
+
+func (r *mutationResolver) EditPost(ctx context.Context, input input.PostEditInput) (models.Post, error) {
+	token := auth.TokenFromContext(ctx)
+	if !token.Authenticated() || !token.Permitted("post.edit") {
+		return models.Post{}, errors.New("You are not permitted to edit logs")
+	}
+
+	post, err := posts.FindID(input.ID)
+	if err != nil {
+		return models.Post{}, errors.New("Post not found")
+	}
+
+	if input.Nick != nil {
+		go func() {
+			log, err := logs.FindID(post.LogID)
+			if err != nil {
+				return
+			}
+
+			logs.UpdateCharacters(log)
+		}()
+	}
+
+	post, err = posts.Edit(post, input.Time, input.Kind, input.Nick, input.Text)
+	if err != nil {
+		return models.Post{}, errors.New("Adding post failed: " + err.Error())
+	}
+
+	go func() {
+		log, err := logs.FindID(post.LogID)
+		if err != nil {
+			log = models.Log{ID: post.LogID}
+		}
+
+		changes.Submit("Post", "edit", token.UserID, true, changekeys.Many(log, post), post)
+	}()
+
+	return post, nil
+}
+
+func (r *mutationResolver) MovePost(ctx context.Context, input input.PostMoveInput) ([]models.Post, error) {
+	token := auth.TokenFromContext(ctx)
+	if !token.Authenticated() || !token.Permitted("post.move") {
+		return nil, errors.New("You are not permitted to edit logs")
+	}
+
+	post, err := posts.FindID(input.ID)
+	if err != nil {
+		return nil, errors.New("Post not found")
+	}
+
+	posts, err := posts.Move(post, input.ToPosition)
+	if err != nil {
+		return nil, errors.New("Moving posts failed: " + err.Error())
+	}
+
+	go func() {
+		log, err := logs.FindID(post.LogID)
+		if err != nil {
+			log = models.Log{ID: post.LogID}
+		}
+
+		changes.Submit("Post", "move", token.UserID, true, changekeys.Many(log, posts), posts)
+	}()
+
+	return posts, nil
+}
+
+func (r *mutationResolver) RemovePost(ctx context.Context, input input.PostRemoveInput) (models.Post, error) {
+	token := auth.TokenFromContext(ctx)
+	if !token.Authenticated() || !token.Permitted("post.remove") {
+		return models.Post{}, errors.New("You are not permitted to edit logs")
+	}
+
+	post, err := posts.FindID(input.ID)
+	if err != nil {
+		return models.Post{}, errors.New("Post not found (before removing, of course)")
+	}
+
+	post, err = posts.Remove(post)
+	if err != nil {
+		return models.Post{}, errors.New("Could not remove post: " + err.Error())
+	}
+
+	go func() {
+		log, err := logs.FindID(post.LogID)
+		if err != nil {
+			return
+		}
+
+		logs.UpdateCharacters(log)
+		changes.Submit("Post", "remove", token.UserID, true, changekeys.Many(log, post), post)
+	}()
+
+	return post, nil
+}

graph2/queries/resolver.go

@@ -0,0 +1,10 @@
+package queries
+
+type resolver struct{}
+type mutationResolver struct{}
+
+// Resolver has all the queries
+var Resolver resolver
+
+// MutationResolver brings the mutagens.
+var MutationResolver *mutationResolver

graph2/queries/story.go

@@ -0,0 +1,169 @@
+package queries
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"git.aiterp.net/rpdata/api/models/changekeys"
+	"git.aiterp.net/rpdata/api/models/changes"
+
+	"git.aiterp.net/rpdata/api/graph2/input"
+	"git.aiterp.net/rpdata/api/internal/auth"
+	"git.aiterp.net/rpdata/api/models"
+	"git.aiterp.net/rpdata/api/models/chapters"
+	"git.aiterp.net/rpdata/api/models/stories"
+)
+
+func (r *resolver) Story(ctx context.Context, id string) (models.Story, error) {
+	return stories.FindID(id)
+}
+
+func (r *resolver) Stories(ctx context.Context, filter *stories.Filter) ([]models.Story, error) {
+	if filter != nil {
+		if filter.Unlisted != nil && *filter.Unlisted == true {
+			token := auth.TokenFromContext(ctx)
+			if !token.Authenticated() {
+				return nil, errors.New("You are not permitted to view unlisted stories")
+			}
+
+			if !token.Permitted("story.unlisted") {
+				filter.Author = &token.UserID
+			}
+		}
+	}
+
+	return stories.List(filter)
+}
+
+// Mutations
+
+func (r *mutationResolver) AddStory(ctx context.Context, input input.StoryAddInput) (models.Story, error) {
+	token := auth.TokenFromContext(ctx)
+	if token == nil || !token.Permitted("member", "story.add") {
+		return models.Story{}, errors.New("Permission denied")
+	}
+
+	author := token.UserID
+	if input.Author != nil && *input.Author != author {
+		if !token.Permitted("story.add") {
+			return models.Story{}, errors.New("You are not permitted to add a story in another author's name")
+		}
+
+		author = *input.Author
+	}
+
+	fictionalDate := time.Time{}
+	if input.FictionalDate != nil {
+		fictionalDate = *input.FictionalDate
+	}
+
+	listed := input.Listed != nil && *input.Listed
+	open := input.Open != nil && *input.Open
+
+	story, err := stories.Add(input.Name, author, input.Category, listed, open, input.Tags, time.Now(), fictionalDate)
+	if err != nil {
+		return models.Story{}, errors.New("Failed to add story: " + err.Error())
+	}
+
+	go changes.Submit("Story", "add", token.UserID, story.Listed, changekeys.Listed(story), story)
+
+	return story, nil
+}
+
+func (r *mutationResolver) AddStoryTag(ctx context.Context, input input.StoryTagAddInput) (models.Story, error) {
+	token := auth.TokenFromContext(ctx)
+
+	story, err := stories.FindID(input.ID)
+	if err != nil {
+		return models.Story{}, errors.New("Story not found")
+	}
+
+	if !token.PermittedUser(story.Author, "member", "story.edit") {
+		return models.Story{}, errors.New("You are not permitted to edit this story")
+	}
+
+	story, err = stories.AddTag(story, input.Tag)
+	if err != nil {
+		return models.Story{}, errors.New("Failed to add story: " + err.Error())
+	}
+
+	go changes.Submit("Story", "tag", token.UserID, story.Listed, changekeys.Listed(story), story, input.Tag)
+
+	return story, nil
+}
+
+func (r *mutationResolver) RemoveStoryTag(ctx context.Context, input input.StoryTagRemoveInput) (models.Story, error) {
+	token := auth.TokenFromContext(ctx)
+
+	story, err := stories.FindID(input.ID)
+	if err != nil {
+		return models.Story{}, errors.New("Story not found")
+	}
+
+	if !token.PermittedUser(story.Author, "member", "story.edit") {
+		return models.Story{}, errors.New("You are not permitted to edit this story")
+	}
+
+	story, err = stories.RemoveTag(story, input.Tag)
+	if err != nil {
+		return models.Story{}, errors.New("Failed to add story: " + err.Error())
+	}
+
+	go changes.Submit("Story", "untag", token.UserID, story.Listed, changekeys.Listed(story), story, input.Tag)
+
+	return story, nil
+}
+
+func (r *mutationResolver) EditStory(ctx context.Context, input input.StoryEditInput) (models.Story, error) {
+	token := auth.TokenFromContext(ctx)
+
+	story, err := stories.FindID(input.ID)
+	if err != nil {
+		return models.Story{}, errors.New("Story not found")
+	}
+
+	if !token.PermittedUser(story.Author, "member", "story.edit") {
+		return models.Story{}, errors.New("You are not permitted to remove this story")
+	}
+
+	if input.ClearFictionalDate != nil && *input.ClearFictionalDate {
+		input.FictionalDate = &time.Time{}
+	}
+
+	story, err = stories.Edit(story, input.Name, input.Category, input.Listed, input.Open, input.FictionalDate)
+	if err != nil {
+		return models.Story{}, errors.New("Failed to add story: " + err.Error())
+	}
+
+	go changes.Submit("Story", "edit", token.UserID, story.Listed, changekeys.Listed(story), story)
+
+	return story, nil
+}
+
+func (r *mutationResolver) RemoveStory(ctx context.Context, input input.StoryRemoveInput) (models.Story, error) {
+	token := auth.TokenFromContext(ctx)
+
+	story, err := stories.FindID(input.ID)
+	if err != nil {
+		return models.Story{}, errors.New("Story not found")
+	}
+
+	if !token.PermittedUser(story.Author, "member", "story.remove") {
+		return models.Story{}, errors.New("You are not permitted to remove this story")
+	}
+
+	story, err = stories.Remove(story)
+	if err != nil {
+		return models.Story{}, err
+	}
+
+	err = chapters.RemoveStory(story)
+	if err != nil {
+		return models.Story{}, errors.New("Failed to remove chapters, but story is removed: " + err.Error())
+	}
+
+	go changes.Submit("Story", "remove", token.UserID, story.Listed, changekeys.Listed(story), story)
+
+	return story, nil
+}

graph2/queries/tags.go

@@ -0,0 +1,12 @@
+package queries
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/models"
+	"git.aiterp.net/rpdata/api/models/tags"
+)
+
+func (r *resolver) Tags(ctx context.Context) ([]models.Tag, error) {
+	return tags.List()
+}

graph2/queries/token.go

@@ -0,0 +1,18 @@
+package queries
+
+import (
+	"context"
+	"errors"
+
+	"git.aiterp.net/rpdata/api/internal/auth"
+	"git.aiterp.net/rpdata/api/models"
+)
+
+func (r *resolver) Token(ctx context.Context) (models.Token, error) {
+	token := auth.TokenFromContext(ctx)
+	if !token.Authenticated() {
+		return models.Token{}, errors.New("No (valid) token")
+	}
+
+	return *token, nil
+}

graph2/schema/root.gql

@@ -0,0 +1,143 @@
+schema {
+  query: Query
+  mutation: Mutation
+}
+
+type Query {
+  # Find character by either an ID or a nick.
+  character(id: String, nick: String): Character!
+
+  # Find characters
+  characters(filter: CharactersFilter): [Character!]!
+
+
+  # Find channel by name
+  channel(name: String!): Channel!
+
+  # Find channels
+  channels(filter: ChannelsFilter): [Channel!]!  
+  
+
+  # Find post by ID.
+  post(id: String!): Post!
+
+  # Find posts
+  posts(filter: PostsFilter): [Post!]!
+
+
+  # Find log by ID
+  log(id: String!): Log!
+
+  # Find logs
+  logs(filter: LogsFilter): [Log!]!
+
+
+  # Find story chapter by ID
+  chapter(id: String!): Chapter!
+
+
+  # Find all distinct tags used in stories
+  tags: [Tag!]!
+
+
+  # Find story by ID
+  story(id: String!): Story!
+
+  # Find stories
+  stories(filter: StoriesFilter): [Story!]!
+
+
+  # Find file by ID
+  file(id: String!): File!
+
+  # Find files
+  files(filter: FilesFilter): [File!]!
+
+
+  # Find changes
+  changes(filter: ChangesFilter): [Change!]!
+
+
+  # Get information about the token, useful for debugging.
+  token: Token!
+}
+
+type Mutation {
+  # Add a story
+  addStory(input: StoryAddInput!): Story!
+  
+  # Add a story tag
+  addStoryTag(input: StoryTagAddInput!): Story!
+  
+  # Remove a story tag
+  removeStoryTag(input: StoryTagRemoveInput!): Story!
+  
+  # Edit a story
+  editStory(input: StoryEditInput!): Story!
+  
+  # Remove a story
+  removeStory(input: StoryRemoveInput!): Story!
+
+
+  # Add a chapter to a story
+  addChapter(input: ChapterAddInput!): Chapter!
+
+  # Edit a chapter
+  editChapter(input: ChapterEditInput!): Chapter!
+
+  # Move a chapter
+  moveChapter(input: ChapterMoveInput!): Chapter!
+
+  # Remove a chapter
+  removeChapter(input: ChapterRemoveInput!): Chapter!
+
+
+  # Add a new log
+  addLog(input: LogAddInput!): Log!
+
+  # Edit a log
+  editLog(input: LogEditInput!): Log!
+
+  # Remove a log
+  removeLog(input: LogRemoveInput!): Log!
+
+
+  # Add a post
+  addPost(input: PostAddInput!): Post!
+
+  # Edit a post
+  editPost(input: PostEditInput!): Post!
+
+  # Move a post. All affected posts will be returned.
+  movePost(input: PostMoveInput!): [Post!]!
+
+  # Remove a post
+  removePost(input: PostRemoveInput!): Post!
+
+
+  # Add a new character
+  addCharacter(input: CharacterAddInput!): Character!
+
+  # Add nick to character
+  addCharacterNick(input: CharacterNickInput!): Character!
+  
+  # Remove nick from character
+  removeCharacterNick(input: CharacterNickInput!): Character!
+
+  # Edit character
+  editCharacter(input: CharacterEditInput!): Character!
+
+  # Remove a character
+  removeCharacter(input: CharacterRemoveInput!): Character!
+
+
+  # Add a channel
+  addChannel(input: ChannelAddInput!): Channel!
+
+  # Edit a channel
+  editChannel(input: ChannelEditInput!): Channel!
+}
+
+# A Date represents a RFC3339 encoded date with up to millisecond precision.
+scalar Date
+

graph2/schema/types/Change.gql

@@ -0,0 +1,81 @@
+"""
+A change represents a a change in the history.
+"""
+type Change {
+  "A unique ID of the change."
+  id: String!
+
+  "The model of the changed object."
+  model: ChangeModel!
+
+  "The operation performed."
+  op: String!
+
+  "The author that performed the change."
+  author: String!
+
+  "Whether the change will be listed without a matching key."
+  listed: Boolean!
+
+  "The keys indexing this change."
+  keys: [ChangeKey!]!
+
+  "The date when the change happened."
+  date: Date
+
+  "The changed objects."
+  objects: [ChangeObject!]!
+}
+
+union ChangeObject = Character | Channel | Log | Post | Story | Tag | Chapter
+
+"""
+A change key is a key associated with a change, used for filtering
+and subscription. A log post edit has keys for both the log and post,
+making it suitable to use it to patch an active log file.
+"""
+type ChangeKey {
+  "The model the key is for."
+  model: ChangeModel!
+
+  "The model's id, or * if it's a key indicating a model list should be updated."
+  id: String!
+}
+
+"""
+See ChangeKey
+"""
+input ChangeKeyInput {
+  "The model the key is for."
+  model: ChangeModel!
+
+  "The model's id, or * if it's a key indicating a model list should be updated."
+  id: String!
+}
+
+"""
+A model related to the change.
+"""
+enum ChangeModel {
+  Character
+  Channel
+  Log
+  Post
+  Story
+  Tag
+  Chapter
+}
+
+"""
+Optional filter for the changes query.
+"""
+input ChangesFilter {
+  "The keys to query for."
+  keys: [ChangeKeyInput!]
+
+  "Only show changes more recent than this date."
+  earliestDate: Date
+
+  "Limit the amount of results."
+  limit: Int
+}

graph2/schema/types/Channel.gql

@@ -16,6 +16,18 @@ type Channel {
   locationName: String
 }
 
+# Filters for the channels query
+input ChannelsFilter {
+  # Filter to either logged or unlogged channels
+  logged: Boolean
+
+  # Filter by event name
+  eventName: String
+
+  # Filter by location name
+  locationName: String
+}
+
 input ChannelAddInput {
   # The channel's name
   name: String!

graph2/schema/types/Chapter.gql

@@ -13,13 +13,13 @@ type Chapter {
   source: String!
 
   # When the chapter was posted initialy
-  createdDate: String!
+  createdDate: Date!
 
   # The in-universe date and time of the chapter
-  fictionalDate: String!
+  fictionalDate: Date
 
   # The date of edit.
-  editedDate: String!
+  editedDate: Date!
 }
 
 # Input for addChapter mutation
@@ -40,7 +40,7 @@ input ChapterAddInput {
   source: String!
 
   # Optionally, assign a fictional date for the chapter
-  fictionalDate: String
+  fictionalDate: Date
 }
 
 # Input for editChapter mutation
@@ -55,5 +55,23 @@ input ChapterEditInput {
   source: String
 
   # Set the fictional date for a chapter
-  fictionalDate: String
+  fictionalDate: Date
+
+  # Remove the fictional date for a chapter
+  clearFictionalDate: Boolean
+}
+
+# Input for moveChapter mutation
+input ChapterMoveInput {
+  # The chapter to move
+  id: String!
+
+  # The story to move it to
+  storyId: String!
+}
+
+# Input for removeChapter mutation
+input ChapterRemoveInput {
+  # The chapter to remove
+  id: String!
 }

graph2/schema/types/Character.gql

@@ -22,6 +22,24 @@ type Character {
   description: String!
 }
 
+# Filter for characters query
+input CharactersFilter {
+  # Filter by character IDs
+  ids: [String!]
+
+  # Filter by nicks
+  nicks: [String!]
+
+  # Filter by names
+  names: [String!]
+
+  # Filter by author
+  author: String
+
+  # Filter by text search matching against the character's description
+  search: String
+}
+
 # Input for adding characters
 input CharacterAddInput {
   # The primary IRC nick name to recognize this character by
@@ -50,6 +68,7 @@ input CharacterNickInput {
   nick: String!
 }
 
+# Inpuit for editCharacter mutation
 input CharacterEditInput {
   # The id for the character to edit
   id: String!
@@ -62,4 +81,11 @@ input CharacterEditInput {
 
   # A short description for the character
   description: String
-}
+}
+
+# Input for removeCharacter mutation
+input CharacterRemoveInput {
+  # The id for the character to edit
+  id: String!
+}
+

graph2/schema/types/File.gql

@@ -7,7 +7,7 @@ type File {
   kind: String!
 
   # The time of uploading
-  time: String!
+  time: Date!
 
   # Whether the file is publicly listable. Someone with knowledge of the ID
   # will still be able to view it, however.
@@ -29,6 +29,15 @@ type File {
   url: String
 }
 
+# Filter for the files quiery.
+input FilesFilter {
+  # If set, this will limit the results to either public or private files.
+  public: Boolean
+
+  # Limit the MIME types of the files.
+  mimeType: [String!]
+}
+
 # Input for editFile mutation
 input EditFileInput {
  # The file's unique ID

graph2/schema/types/Log.gql

@@ -8,7 +8,7 @@ type Log {
   shortId: String!
 
   # The date for a log.
-  date: String!
+  date: Date!
 
   # The channel of a log.
   channelName: String!
@@ -21,7 +21,7 @@ type Log {
 
   # The log's event, which is the same as the tags in the previous logbot site.
   # Empty string means that it's no event.
-  event: String!
+  eventName: String!
 
   # The description of a session, which is empty if unset.
   description: String!
@@ -50,17 +50,17 @@ input LogsFilter {
   # Search post content
   search: String
 
-  # Limit to only open logs
+  # Limit by whether it's open or not
   open: Boolean
 
-  # Limit the amount of posts
+  # Limit the amount of results you get back
   limit: Int
 }
 
 # Input for addLog mutation
 input LogAddInput {
-  # The date of the log, in RFC3339 format with up to nanosecond precision
-  date: String!
+  # The date of the log.
+  date: Date!
 
   # The channel where the log is set
   channel: String!
@@ -96,37 +96,8 @@ input LogEditInput {
   open: Boolean
 }
 
-# A LogHeader is a cut-down version of Log that does not allow getting the actual posts.
-type LogHeader {
-  # A unique identifier for the log.
+# Input for removeLog mutation
+input LogRemoveInput {
+  # The id of the log to remove
   id: String!
-
-  # A secondary unique identifier for the log. This is a lot shorter and more suitable for storage when
-  # the link doesn't need to be as expressive.
-  shortId: String!
-
-  # The date for a log.
-  date: String!
-
-  # The channel name of a log.
-  channelName: String!
-
-  # Information about the channel this log is in.
-  channel: Channel!
-  
-  # The session's title.
-  title: String!
-
-  # The log's event, which is the same as the tags in the previous logbot site.
-  # Empty string means that it's no event.
-  event: String!
-
-  # The description of a session, which is empty if unset.
-  description: String!
-
-  # Whether the log session is open.
-  open: Boolean!
-
-  # The characters involved in the log file.
-  characters: [Character!]!
-}
+}

graph2/schema/types/Post.gql

@@ -7,7 +7,7 @@ type Post {
   logId: String!
 
   # The date and time of posting
-  time: String!
+  time: Date!
 
   # The kind of post this is. Only "text", "scene" and "action" are RP, while others are annotations and 'commands'.
   kind: String!
@@ -23,12 +23,12 @@ type Post {
 }
 
 # Input for the addPost mutation
-input AddPostInput {
+input PostAddInput {
   # The log's ID that this post should be a part of
   logId: String!
 
   # The date and time of posting, in a RFC3339 format with up to a nanosecond's precision
-  time: String!
+  time: Date!
 
   # The kind of post this is. Only "text", "scene" and "action" are RP, while others are annotations and 'commands'.
   kind: String!
@@ -41,12 +41,12 @@ input AddPostInput {
 }
 
 # Input for the editPost mutation
-input EditPostInput {
+input PostEditInput {
   # The Post ID
   id: String!
 
   # The date and time of posting, in a RFC3339 format with up to a nanosecond's precision
-  time: String
+  time: Date
 
   # The kind of post this is. Only "text", "scene" and "action" are RP, while others are annotations and 'commands'.
   kind: String
@@ -59,10 +59,24 @@ input EditPostInput {
 }
 
 # Input for the movePost mutation
-input MovePostInput {
+input PostMoveInput {
   # The Post ID
   id: String!
 
   # Target index
   toPosition: Int!
+}
+
+# Input for the removePost mutation
+input PostRemoveInput {
+  # The Post ID
+  id: String!
+}
+
+# Filter for posts query
+input PostsFilter {
+  id: [String!]
+  kind: [String!]
+  logId: String
+  limit: Int
 }

graph2/schema/types/Story.gql

@@ -25,14 +25,14 @@ type Story {
   # The chapters of this story
   chapters: [Chapter!]!
 
-  # The date the story was created (RFC3339 format).
-  createdDate: String!
+  # The date the story was created.
+  createdDate: Date!
 
-  # The date the story is set in (RFC3339 format).
-  fictionalDate: String!
+  # The date the story is set in.
+  fictionalDate: Date
 
-  # The date of the last major update to the story (RFC3339 format). This being bumped means a new chapter has been added.
-  updatedDate: String!
+  # The date of the last major update to the story. This being bumped means a new chapter has been added.
+  updatedDate: Date!
 }
 
 # Filter for stories query.
@@ -40,14 +40,23 @@ input StoriesFilter {
   # What author to query for
   author: String
 
+  # What category to query for
+  category: StoryCategory
+
   # What tags to query for
   tags: [TagInput!]
 
+  # If true, it will only show unlisted page you have access to
+  unlisted: Boolean
+
+  # Whether the page is open for additions by other users
+  open: Boolean
+
   # The earliest fictionalDate
-  earliestFictionalDate: String
+  earliestFictionalDate: Date
 
   # The latest fictionalDate
-  latestFictionalDate: String
+  latestFictionalDate: Date
 
   # The max amount of stories to get (default: 30)
   limit: Int
@@ -75,8 +84,8 @@ input StoryAddInput {
   # Set which tags the story should have.
   tags: [TagInput!]
 
-  # Set the fictional date of the story (RFC3339 format).
-  fictionalDate: String
+  # Set the fictional date of the story.
+  fictionalDate: Date
 }
 
 # Input for the editStory mutation
@@ -101,8 +110,11 @@ input StoryEditInput {
   # Change whether to show this story in the list and search results
   listed: Boolean
 
-  # Set the fictional date of the story (RFC3339 format).
-  fictionalDate: String
+  # Set the fictional date of the story.
+  fictionalDate: Date
+
+  # Clear the fictional date of the story.
+  clearFictionalDate: Boolean
 }
 
 # Input for the addStoryTag mutation
@@ -123,20 +135,26 @@ input StoryTagRemoveInput {
   tag: TagInput!
 }
 
+# Input for the removeStory mutation
+input StoryRemoveInput {
+  # What story to remove.
+  id: String!
+}
+
 # Possible values for Story.category
 enum StoryCategory {
-  # Description and content of a document or item
-  Document
+  # General information
+  Info
 
   # News stories
   News
 
+  # Description and content of a document or item
+  Document
+
   # Information about something going on in the background that may or may not inform RP
   Background
 
-  # General information
-  Info
-
   # A short story
   Story
 }

graph2/schema/types/Tag.gql

@@ -33,4 +33,5 @@ enum TagKind {
 
   # None of the above, but it does still tie multiple stories together. The new story/chapter format may obsolete this tag kind.
   Series
-}
+}
+

graph2/schema/types/Token.gql

@@ -0,0 +1,8 @@
+# Token represents the data parsed and validated from the bearer token.
+type Token {
+  # The user represented in the token.
+  user: User!
+
+  # The permissions for the token.
+  permissions: [String!]!
+}

graph2/schema/types/User.gql

@@ -0,0 +1,8 @@
+# A user represents a member on the RPData platform.
+type User {
+  # The user's unique ID / username
+  id: String!
+
+  # What the user is permitted to do.
+  permissions: [String!]!
+}

graph2/types/change.go

@@ -0,0 +1,24 @@
+package types
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/graph2/input"
+	"git.aiterp.net/rpdata/api/models"
+)
+
+type changeResolver struct{}
+
+func (r *changeResolver) Objects(ctx context.Context, obj *models.Change) ([]input.ChangeObject, error) {
+	objects := obj.Objects()
+
+	results := make([]input.ChangeObject, len(objects))
+	for i := range objects {
+		results[i] = objects[i]
+	}
+
+	return results, nil
+}
+
+// ChangeResolver is a resolver
+var ChangeResolver changeResolver

graph2/types/chapter.go

@@ -0,0 +1,21 @@
+package types
+
+import (
+	"context"
+	"time"
+
+	"git.aiterp.net/rpdata/api/models"
+)
+
+type chapterResolver struct{}
+
+func (r *chapterResolver) FictionalDate(ctx context.Context, chapter *models.Chapter) (*time.Time, error) {
+	if chapter.FictionalDate.IsZero() {
+		return nil, nil
+	}
+
+	return &chapter.FictionalDate, nil
+}
+
+// ChapterResolver is a resolver
+var ChapterResolver chapterResolver

graph2/types/file.go

@@ -0,0 +1,16 @@
+package types
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/models"
+)
+
+type fileResolver struct{}
+
+func (r *fileResolver) Size(ctx context.Context, file *models.File) (int, error) {
+	return int(file.Size), nil
+}
+
+// FileResolver is a resolver
+var FileResolver fileResolver

graph2/types/log.go

@@ -0,0 +1,41 @@
+package types
+
+import (
+	"context"
+	"errors"
+
+	"git.aiterp.net/rpdata/api/internal/loader"
+	"git.aiterp.net/rpdata/api/models"
+	"git.aiterp.net/rpdata/api/models/posts"
+)
+
+type logResolver struct{}
+
+func (r *logResolver) Channel(ctx context.Context, log *models.Log) (models.Channel, error) {
+	loader := loader.FromContext(ctx)
+	if loader == nil {
+		return models.Channel{}, errors.New("no loader")
+	}
+
+	return loader.Channel("name", log.ChannelName)
+}
+
+func (r *logResolver) Characters(ctx context.Context, log *models.Log) ([]models.Character, error) {
+	loader := loader.FromContext(ctx)
+	if loader == nil {
+		return nil, errors.New("no loader")
+	}
+
+	return loader.Characters("id", log.CharacterIDs...)
+}
+
+func (r *logResolver) Posts(ctx context.Context, log *models.Log, kinds []string) ([]models.Post, error) {
+	return posts.List(&posts.Filter{
+		LogID: &log.ShortID,
+		Kind:  kinds,
+		Limit: 0,
+	})
+}
+
+// LogResolver is a resolver
+var LogResolver logResolver

graph2/types/story.go

@@ -0,0 +1,27 @@
+package types
+
+import (
+	"context"
+	"time"
+
+	"git.aiterp.net/rpdata/api/models/chapters"
+
+	"git.aiterp.net/rpdata/api/models"
+)
+
+type storyResolver struct{}
+
+func (r *storyResolver) FictionalDate(ctx context.Context, story *models.Story) (*time.Time, error) {
+	if story.FictionalDate.IsZero() {
+		return nil, nil
+	}
+
+	return &story.FictionalDate, nil
+}
+
+func (r *storyResolver) Chapters(ctx context.Context, story *models.Story) ([]models.Chapter, error) {
+	return chapters.ListStoryID(story.ID)
+}
+
+// StoryResolver is a resolver
+var StoryResolver storyResolver

graph2/types/token.go

@@ -0,0 +1,17 @@
+package types
+
+import (
+	"context"
+
+	"git.aiterp.net/rpdata/api/models"
+	"git.aiterp.net/rpdata/api/models/users"
+)
+
+type tokenResolver struct{}
+
+func (r *tokenResolver) User(ctx context.Context, token *models.Token) (models.User, error) {
+	return users.Find(token.UserID)
+}
+
+// TokenResolver is a resolver
+var TokenResolver tokenResolver

graphql/resolver/channel.go

@@ -1,156 +0,0 @@
-package resolver
-
-import (
-	"context"
-
-	"git.aiterp.net/rpdata/api/graphql/resolver/types"
-	"git.aiterp.net/rpdata/api/internal/session"
-	"git.aiterp.net/rpdata/api/model/change"
-	"git.aiterp.net/rpdata/api/model/channel"
-)
-
-// ChannelArgs is args for channel query
-type ChannelArgs struct {
-	Name string
-}
-
-// Channel implements the channel query
-func (r *QueryResolver) Channel(ctx context.Context, args *ChannelArgs) (*types.ChannelResolver, error) {
-	channel, err := channel.FindName(args.Name)
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.ChannelResolver{C: channel}, nil
-}
-
-// ChannelsArgs is args for channel query
-type ChannelsArgs struct {
-	Logged *bool
-}
-
-// Channels implements the channels query
-func (r *QueryResolver) Channels(ctx context.Context, args *ChannelsArgs) ([]*types.ChannelResolver, error) {
-	channels, err := channel.List(args.Logged != nil && *args.Logged)
-	if err != nil {
-		return nil, err
-	}
-
-	resolvers := make([]*types.ChannelResolver, len(channels))
-	for i := range channels {
-		resolvers[i] = &types.ChannelResolver{C: channels[i]}
-	}
-
-	return resolvers, nil
-}
-
-// ChannelAddArgs is input for the addChannel mutation
-type ChannelAddArgs struct {
-	Input *struct {
-		Name         string
-		Logged       *bool
-		Hub          *bool
-		EventName    *string
-		LocationName *string
-	}
-}
-
-// AddChannel resolves the addChannel mutation
-func (r *MutationResolver) AddChannel(ctx context.Context, args *ChannelAddArgs) (*types.ChannelResolver, error) {
-	input := args.Input
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("channel.add") {
-		return nil, ErrUnauthorized
-	}
-
-	logged := input.Logged != nil && *input.Logged
-
-	hub := input.Hub != nil && *input.Hub
-
-	eventName := ""
-	if input.EventName != nil {
-		eventName = *input.EventName
-	}
-
-	locationName := ""
-	if input.LocationName != nil {
-		locationName = *input.LocationName
-	}
-
-	channel, err := channel.New(input.Name, logged, hub, eventName, locationName)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Channel", "add", user.ID, channel.Name, map[string]interface{}{
-		"logged":   channel.Logged,
-		"hub":      channel.Hub,
-		"location": input.LocationName,
-		"event":    input.EventName,
-	})
-
-	return &types.ChannelResolver{C: channel}, nil
-}
-
-// ChannelEditArgs is input for the editChannel mutation
-type ChannelEditArgs struct {
-	Input *struct {
-		Name         string
-		Logged       *bool
-		Hub          *bool
-		EventName    *string
-		LocationName *string
-	}
-}
-
-// EditChannel resolves the editChannel mutation
-func (r *MutationResolver) EditChannel(ctx context.Context, args *ChannelEditArgs) (*types.ChannelResolver, error) {
-	input := args.Input
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("channel.edit") {
-		return nil, ErrUnauthorized
-	}
-
-	channel, err := channel.FindName(input.Name)
-	if err != nil {
-		return nil, err
-	}
-
-	err = channel.Edit(input.Logged, input.Hub, input.EventName, input.LocationName)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Channel", "edit", user.ID, channel.Name, map[string]interface{}{
-		"logged":   input.Logged,
-		"hub":      input.Hub,
-		"location": input.LocationName,
-		"event":    input.EventName,
-	})
-
-	return &types.ChannelResolver{C: channel}, nil
-}
-
-// RemoveChannel resolves the editChannel mutation
-func (r *MutationResolver) RemoveChannel(ctx context.Context, args ChannelArgs) (*types.ChannelResolver, error) {
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("channel.remove") {
-		return nil, ErrUnauthorized
-	}
-
-	channel, err := channel.FindName(args.Name)
-	if err != nil {
-		return nil, err
-	}
-
-	err = channel.Remove()
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Channel", "remove", user.ID, channel.Name, nil)
-
-	return &types.ChannelResolver{C: channel}, nil
-}

graphql/resolver/chapter.go

@@ -1,161 +0,0 @@
-package resolver
-
-import (
-	"context"
-	"time"
-
-	"git.aiterp.net/rpdata/api/graphql/resolver/types"
-	"git.aiterp.net/rpdata/api/internal/session"
-	"git.aiterp.net/rpdata/api/model/change"
-	"git.aiterp.net/rpdata/api/model/story"
-)
-
-// ChapterArgs is args for chapter query
-type ChapterArgs struct {
-	ID string
-}
-
-// Chapter implements the chapter query
-func (r *QueryResolver) Chapter(ctx context.Context, args *ChapterArgs) (*types.ChapterResolver, error) {
-	chapter, err := story.FindChapterID(args.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.ChapterResolver{C: chapter}, nil
-}
-
-// AddChapterArgs is args for the addChapter mutation
-type AddChapterArgs struct {
-	Input *struct {
-		StoryID       string
-		Title         string
-		Author        *string
-		Source        string
-		FictionalDate *string
-	}
-}
-
-// AddChapter implements the addChapter mutation
-func (r *MutationResolver) AddChapter(ctx context.Context, args *AddChapterArgs) (*types.ChapterResolver, error) {
-	input := args.Input
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("member", "chapter.add") {
-		return nil, ErrUnauthorized
-	}
-
-	story, err := story.FindID(input.StoryID)
-	if err != nil {
-		return nil, err
-	}
-
-	author := user.ID
-	if input.Author != nil {
-		author = *input.Author
-
-		if user.ID != author && !user.Permitted("chapter.add") {
-			return nil, ErrPermissionDenied
-		}
-	}
-
-	fictionalDate := time.Time{}
-	if input.FictionalDate != nil {
-		fictionalDate, err = time.Parse(time.RFC3339Nano, *input.FictionalDate)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	chapter, err := story.AddChapter(input.Title, author, input.Source, time.Now(), fictionalDate)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Chapter", "add", user.ID, chapter.ID, map[string]interface{}{
-		"title":         input.Title,
-		"author":        author,
-		"fictionalDate": fictionalDate,
-	})
-
-	return &types.ChapterResolver{C: chapter}, nil
-}
-
-// EditChapterArgs is args for the editChapter mutation
-type EditChapterArgs struct {
-	Input *struct {
-		ID            string
-		Title         *string
-		Source        *string
-		FictionalDate *string
-	}
-}
-
-// EditChapter implements the editChapter mutation
-func (r *MutationResolver) EditChapter(ctx context.Context, args *EditChapterArgs) (*types.ChapterResolver, error) {
-	input := args.Input
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("member", "chapter.edit") {
-		return nil, ErrUnauthorized
-	}
-
-	chapter, err := story.FindChapterID(input.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	if chapter.Author != user.ID && !user.Permitted("chapter.edit") {
-		return nil, ErrPermissionDenied
-	}
-
-	var fictionalDate *time.Time
-	if input.FictionalDate != nil {
-		date, err := time.Parse(time.RFC3339Nano, *input.FictionalDate)
-		if err != nil {
-			return nil, err
-		}
-
-		fictionalDate = &date
-	}
-
-	err = chapter.Edit(input.Title, input.Source, fictionalDate)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Chapter", "edit", user.ID, chapter.ID, map[string]interface{}{
-		"title":         input.Title,
-		"source":        input.Source,
-		"fictionalDate": fictionalDate,
-	})
-
-	return &types.ChapterResolver{C: chapter}, nil
-}
-
-// DeleteChapterArgs is args for the addChapter mutation
-type DeleteChapterArgs struct {
-	ID string
-}
-
-// RemoveChapter implements the removeChapter mutation
-func (r *MutationResolver) RemoveChapter(ctx context.Context, args *DeleteChapterArgs) (*types.ChapterResolver, error) {
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("member", "chapter.edit") {
-		return nil, ErrUnauthorized
-	}
-
-	chapter, err := story.FindChapterID(args.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	err = chapter.Remove()
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Chapter", "remove", user.ID, chapter.ID, nil)
-
-	return &types.ChapterResolver{C: chapter}, nil
-}

graphql/resolver/character.go

@@ -1,299 +0,0 @@
-package resolver
-
-import (
-	"context"
-	"errors"
-	"strings"
-
-	"git.aiterp.net/rpdata/api/graphql/loader"
-	"git.aiterp.net/rpdata/api/graphql/resolver/types"
-	"git.aiterp.net/rpdata/api/internal/session"
-	"git.aiterp.net/rpdata/api/model/change"
-	"git.aiterp.net/rpdata/api/model/character"
-	"git.aiterp.net/rpdata/api/model/log"
-)
-
-// CharacterArgs is an arg
-type CharacterArgs struct {
-	ID   *string
-	Nick *string
-}
-
-// Character resolver
-func (r *QueryResolver) Character(ctx context.Context, args *CharacterArgs) (*types.CharacterResolver, error) {
-	var char character.Character
-	var err error
-
-	loader := loader.FromContext(ctx)
-	if loader == nil {
-		return nil, errors.New("no loader")
-	}
-
-	switch {
-	case args.ID != nil:
-		char, err = character.FindID(*args.ID)
-	case args.Nick != nil:
-		char, err = character.FindNick(*args.Nick)
-	default:
-		err = ErrCannotResolve
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.CharacterResolver{C: char}, nil
-}
-
-// CharactersArgs is an arg
-type CharactersArgs struct {
-	IDs    *[]string
-	Nicks  *[]string
-	Author *string
-}
-
-// Characters resolves the characters query
-func (r *QueryResolver) Characters(ctx context.Context, args *CharactersArgs) ([]*types.CharacterResolver, error) {
-	var chars []character.Character
-	var err error
-
-	loader := loader.FromContext(ctx)
-	if loader == nil {
-		return nil, errors.New("no loader")
-	}
-
-	switch {
-	case args.IDs != nil:
-		chars, err = character.ListIDs(*args.IDs...)
-	case args.Nicks != nil:
-		chars, err = character.ListNicks(*args.Nicks...)
-	case args.Author != nil:
-		chars, err = character.ListAuthor(*args.Author)
-	default:
-		chars, err = character.List()
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	resolvers := make([]*types.CharacterResolver, 0, len(chars))
-	for i := range chars {
-		if chars[i].ID == "" {
-			continue
-		}
-
-		resolvers = append(resolvers, &types.CharacterResolver{C: chars[i]})
-	}
-
-	return resolvers, nil
-}
-
-// AddCharacterInput is args for the addCharacter mutation
-type AddCharacterInput struct {
-	Nick        string
-	Name        string
-	ShortName   *string
-	Author      *string
-	Description *string
-}
-
-// AddCharacter resolves the addCharacter mutation
-func (r *MutationResolver) AddCharacter(ctx context.Context, args struct{ Input *AddCharacterInput }) (*types.CharacterResolver, error) {
-	input := args.Input
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("member", "character.add") {
-		return nil, ErrUnauthorized
-	}
-
-	nick := input.Nick
-
-	name := input.Name
-
-	shortName := ""
-	if input.ShortName != nil {
-		shortName = *input.ShortName
-	} else {
-		shortName = strings.SplitN(input.Name, " ", 2)[0]
-	}
-
-	author := user.ID
-	if input.Author != nil {
-		author = *input.Author
-
-		if author != user.ID && !user.Permitted("character.add") {
-			return nil, ErrPermissionDenied
-		}
-	}
-
-	description := ""
-	if input.Description != nil {
-		description = *input.Description
-	}
-
-	character, err := character.New(nick, name, shortName, author, description)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Character", "add", user.ID, character.ID, map[string]interface{}{
-		"name":   character.Name,
-		"nick":   character.Nicks[0],
-		"author": character.Author,
-	})
-
-	log.ScheduleCharacterUpdate()
-
-	return &types.CharacterResolver{C: character}, nil
-}
-
-// CharacterNickInput is args for mutation addCharacterNick/removeCharacterNick
-type CharacterNickInput struct {
-	ID   string
-	Nick string
-}
-
-// AddCharacterNick resolves the addCharacterNick mutation
-func (r *MutationResolver) AddCharacterNick(ctx context.Context, args struct{ Input *CharacterNickInput }) (*types.CharacterResolver, error) {
-	input := args.Input
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("member") {
-		return nil, ErrUnauthorized
-	}
-
-	character, err := character.FindID(input.ID)
-	if err != nil {
-		return nil, err
-	}
-	if character.Author != user.ID && !user.Permitted("character.edit") {
-		return nil, ErrPermissionDenied
-	}
-
-	err = character.AddNick(input.Nick)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Character", "add.nick", user.ID, character.ID, map[string]interface{}{
-		"nick": input.Nick,
-	})
-
-	log.ScheduleCharacterUpdate()
-
-	return &types.CharacterResolver{C: character}, nil
-}
-
-// RemoveCharacterNick resolves the removeCharacterNick mutation
-func (r *MutationResolver) RemoveCharacterNick(ctx context.Context, args struct{ Input *CharacterNickInput }) (*types.CharacterResolver, error) {
-	input := args.Input
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("member") {
-		return nil, ErrUnauthorized
-	}
-
-	character, err := character.FindID(input.ID)
-	if err != nil {
-		return nil, err
-	}
-	if character.Author != user.ID && !user.Permitted("character.edit") {
-		return nil, ErrPermissionDenied
-	}
-
-	err = character.RemoveNick(input.Nick)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Character", "remove.nick", user.ID, character.ID, map[string]interface{}{
-		"nick": input.Nick,
-	})
-
-	log.ScheduleCharacterUpdate()
-
-	return &types.CharacterResolver{C: character}, nil
-}
-
-// CharacterEditInput is args for mutation addCharacterNick/removeCharacterNick
-type CharacterEditInput struct {
-	ID          string
-	Name        *string
-	ShortName   *string
-	Description *string
-}
-
-// EditCharacter resolves the editCharacter mutation
-func (r *MutationResolver) EditCharacter(ctx context.Context, args struct{ Input *CharacterEditInput }) (*types.CharacterResolver, error) {
-	input := args.Input
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("member") {
-		return nil, ErrUnauthorized
-	}
-
-	character, err := character.FindID(input.ID)
-	if err != nil {
-		return nil, err
-	}
-	if character.Author != user.ID && !user.Permitted("character.edit") {
-		return nil, ErrPermissionDenied
-	}
-
-	name := ""
-	if input.Name != nil {
-		name = *input.Name
-	}
-
-	shortName := ""
-	if input.ShortName != nil {
-		shortName = *input.ShortName
-	}
-
-	description := ""
-	if input.Description != nil {
-		description = *input.Description
-	}
-
-	err = character.Edit(name, shortName, description)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Character", "edit", user.ID, character.ID, map[string]interface{}{
-		"name":        character.Name,
-		"shortName":   character.ShortName,
-		"description": character.Description,
-	})
-
-	return &types.CharacterResolver{C: character}, nil
-}
-
-// RemoveCharacter resolves the removeCharacter mutation
-func (r *MutationResolver) RemoveCharacter(ctx context.Context, args struct{ ID string }) (*types.CharacterResolver, error) {
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("member") {
-		return nil, ErrUnauthorized
-	}
-
-	character, err := character.FindID(args.ID)
-	if err != nil {
-		return nil, err
-	}
-	if character.Author != user.ID && !user.Permitted("character.remove") {
-		return nil, ErrPermissionDenied
-	}
-
-	err = character.Remove()
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Character", "remove", user.ID, character.ID, map[string]interface{}{
-		"name":   character.Name,
-		"author": character.Author,
-		"nicks":  character.Nicks,
-	})
-
-	return &types.CharacterResolver{C: character}, nil
-}

graphql/resolver/error.go

@@ -1,15 +0,0 @@
-package resolver
-
-import "errors"
-
-// ErrCannotResolve is returned when a resolver constructor is at its wit's end
-var ErrCannotResolve = errors.New("Cannot resolve due to invalid arguments")
-
-// ErrNotImplemented is for TODOs
-var ErrNotImplemented = errors.New("Resolver not implemented")
-
-// ErrUnauthorized is when a guest acts like they own the place
-var ErrUnauthorized = errors.New("Unauthorized")
-
-// ErrPermissionDenied is returned when users act above their station
-var ErrPermissionDenied = errors.New("Permission denied")

graphql/resolver/file.go

@@ -1,115 +0,0 @@
-package resolver
-
-import (
-	"context"
-
-	"git.aiterp.net/rpdata/api/graphql/resolver/types"
-	"git.aiterp.net/rpdata/api/internal/session"
-	"git.aiterp.net/rpdata/api/model/file"
-)
-
-// FileArgs is an arg
-type FileArgs struct {
-	ID string
-}
-
-// File implements the file query
-func (r *QueryResolver) File(ctx context.Context, args *FileArgs) (*types.FileResolver, error) {
-	file, err := file.FindID(args.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.FileResolver{F: file}, nil
-}
-
-// FilesArgs is an arg
-type FilesArgs struct {
-	IncludePublic *bool
-	MimeTypes     *[]string
-}
-
-// Files implements the file query
-func (r *QueryResolver) Files(ctx context.Context, args *FilesArgs) ([]*types.FileResolver, error) {
-	user := session.FromContext(ctx).User()
-	author := ""
-	if user != nil {
-		author = user.ID
-	}
-
-	public := args.IncludePublic != nil && *args.IncludePublic == true
-
-	mimeTypes := []string(nil)
-	if args.MimeTypes != nil {
-		mimeTypes = *args.MimeTypes
-	}
-
-	files, err := file.List(author, public, mimeTypes)
-	if err != nil {
-		return nil, err
-	}
-
-	resolvers := make([]*types.FileResolver, len(files))
-	for i := range files {
-		resolvers[i] = &types.FileResolver{F: files[i]}
-	}
-
-	return resolvers, nil
-}
-
-// FileEditArgs is args for the editFile mutation
-type FileEditArgs struct {
-	Input *struct {
-		ID     string
-		Name   *string
-		Public *bool
-	}
-}
-
-// EditFile resolves the editFile mutation
-func (r *MutationResolver) EditFile(ctx context.Context, args *FileEditArgs) (*types.FileResolver, error) {
-	input := args.Input
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("member") {
-		return nil, ErrUnauthorized
-	}
-
-	file, err := file.FindID(input.ID)
-	if err != nil {
-		return nil, err
-	}
-	if file.Author != user.ID && !user.Permitted("file.edit") {
-		return nil, ErrUnauthorized
-	}
-
-	err = file.Edit(input.Name, input.Public)
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.FileResolver{F: file}, nil
-}
-
-// RemoveFile resolves the removeFIle mutation
-func (r *MutationResolver) RemoveFile(ctx context.Context, args *FileArgs) (*types.FileResolver, error) {
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("member") {
-		return nil, ErrUnauthorized
-	}
-
-	file, err := file.FindID(args.ID)
-	if err != nil {
-		return nil, err
-	}
-	if file.Author != user.ID && !user.Permitted("file.remove") {
-		return nil, ErrUnauthorized
-	}
-
-	err = file.Delete()
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.FileResolver{F: file}, nil
-}

graphql/resolver/log.go

@@ -1,229 +0,0 @@
-package resolver
-
-import (
-	"context"
-	"time"
-
-	"git.aiterp.net/rpdata/api/graphql/resolver/types"
-	"git.aiterp.net/rpdata/api/model/change"
-
-	"git.aiterp.net/rpdata/api/internal/session"
-	"git.aiterp.net/rpdata/api/model/log"
-)
-
-// LogArgs is an arg
-type LogArgs struct {
-	ID *string
-}
-
-// Log finds log
-func (r *QueryResolver) Log(ctx context.Context, args *LogArgs) (*types.LogResolver, error) {
-	var l log.Log
-	var err error
-
-	switch {
-	case args.ID != nil:
-		l, err = log.FindID(*args.ID)
-	default:
-		err = ErrCannotResolve
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.LogResolver{L: l}, nil
-}
-
-// LogQueryArgs is args for the logs query
-type LogQueryArgs struct {
-	Filter *struct {
-		Search     *string
-		Characters *[]string
-		Channels   *[]string
-		Events     *[]string
-		Open       *bool
-		Limit      *int32
-	}
-}
-
-// Logs resolves the logs query
-func (r *QueryResolver) Logs(ctx context.Context, args *LogQueryArgs) ([]*types.LogResolver, error) {
-	var logs []log.Log
-	var err error
-
-	filter := args.Filter
-
-	if filter != nil {
-		limit := 100
-		search := ""
-
-		if filter.Search != nil {
-			search = *filter.Search
-			limit = 0
-		}
-
-		channels := []string(nil)
-		if filter.Channels != nil {
-			channels = *filter.Channels
-			limit = 0
-		}
-
-		characters := []string(nil)
-		if filter.Characters != nil {
-			characters = *filter.Characters
-			limit = 0
-		}
-
-		events := []string(nil)
-		if filter.Events != nil {
-			events = *filter.Events
-			limit = 0
-		}
-
-		if filter.Limit != nil {
-			limit = int(*filter.Limit)
-		}
-
-		open := filter.Open != nil && *filter.Open == true
-
-		logs, err = log.ListSearch(search, channels, characters, events, open, limit)
-		if err != nil {
-			return nil, err
-		}
-	} else {
-		logs, err = log.List(100)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	resolvers := make([]*types.LogResolver, len(logs))
-	for i := range logs {
-		resolvers[i] = &types.LogResolver{L: logs[i]}
-	}
-
-	return resolvers, nil
-}
-
-// LogAddArgs is args for the addLog mutation
-type LogAddArgs struct {
-	Input *struct {
-		Date        string
-		Channel     string
-		Title       *string
-		Open        *bool
-		Event       *string
-		Description *string
-	}
-}
-
-// AddLog resolves the addLog mutation
-func (r *MutationResolver) AddLog(ctx context.Context, args *LogAddArgs) (*types.LogResolver, error) {
-	input := args.Input
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("log.add") {
-		return nil, ErrUnauthorized
-	}
-
-	date, err := time.Parse(time.RFC3339Nano, args.Input.Date)
-	if err != nil {
-		return nil, err
-	}
-
-	title := ""
-	if input.Title != nil {
-		title = *input.Title
-	}
-
-	event := ""
-	if input.Event != nil {
-		event = *input.Event
-	}
-
-	description := ""
-	if input.Description != nil {
-		description = *input.Description
-	}
-
-	open := input.Open != nil && *input.Open == true
-
-	log, err := log.New(date, input.Channel, title, event, description, open)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Log", "add", user.ID, log.ID, map[string]interface{}{
-		"channel":     log.Channel,
-		"title":       log.Title,
-		"event":       log.Event,
-		"description": log.Description,
-		"open":        log.Open,
-	})
-
-	return &types.LogResolver{L: log}, nil
-}
-
-// LogEditArgs is an input
-type LogEditArgs struct {
-	Input *struct {
-		ID          string
-		Title       *string
-		Event       *string
-		Description *string
-		Open        *bool
-	}
-}
-
-// EditLog resolves the editLog mutation
-func (r *MutationResolver) EditLog(ctx context.Context, args *LogEditArgs) (*types.LogResolver, error) {
-	input := args.Input
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("log.edit") {
-		return nil, ErrUnauthorized
-	}
-
-	log, err := log.FindID(input.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	err = log.Edit(input.Title, input.Event, input.Description, input.Open)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Log", "edit", user.ID, log.ID, map[string]interface{}{
-		"channel":     log.Channel,
-		"title":       input.Title,
-		"event":       input.Event,
-		"description": input.Description,
-		"open":        input.Open,
-	})
-
-	return &types.LogResolver{L: log}, nil
-}
-
-// RemoveLog resolves the removeLog mutation
-func (r *MutationResolver) RemoveLog(ctx context.Context, args *struct{ ID string }) (*types.LogResolver, error) {
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("log.remove") {
-		return nil, ErrUnauthorized
-	}
-
-	log, err := log.FindID(args.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	err = log.Remove()
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Log", "remove", user.ID, log.ID, nil)
-
-	return &types.LogResolver{L: log}, nil
-}

graphql/resolver/post.go

@@ -1,208 +0,0 @@
-package resolver
-
-import (
-	"context"
-	"time"
-
-	"git.aiterp.net/rpdata/api/graphql/resolver/types"
-	"git.aiterp.net/rpdata/api/internal/session"
-	"git.aiterp.net/rpdata/api/model/change"
-	"git.aiterp.net/rpdata/api/model/log"
-)
-
-// PostArgs is an arg
-type PostArgs struct {
-	ID string
-}
-
-// Post implements the post query
-func (r *QueryResolver) Post(ctx context.Context, args *PostArgs) (*types.PostResolver, error) {
-	post, err := log.FindPostID(args.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.PostResolver{P: post}, nil
-}
-
-// PostsArgs is an arg
-type PostsArgs struct {
-	IDs []string
-}
-
-// Posts implements the posts query
-func (r *QueryResolver) Posts(ctx context.Context, args *PostsArgs) ([]*types.PostResolver, error) {
-	posts, err := log.ListPostIDs(args.IDs...)
-	if err != nil {
-		return nil, err
-	}
-
-	resolvers := make([]*types.PostResolver, len(posts))
-	for i := range resolvers {
-		resolvers[i] = &types.PostResolver{P: posts[i]}
-	}
-
-	return resolvers, nil
-}
-
-// PostAddArgs is args for addPost mutation
-type PostAddArgs struct {
-	Input *struct {
-		LogID string
-		Time  string
-		Kind  string
-		Nick  string
-		Text  string
-	}
-}
-
-// AddPost resolves the addPost mutation
-func (r *MutationResolver) AddPost(ctx context.Context, args *PostAddArgs) (*types.PostResolver, error) {
-	input := args.Input
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("post.add") {
-		return nil, ErrUnauthorized
-	}
-
-	postTime, err := time.Parse(time.RFC3339Nano, input.Time)
-	if err != nil {
-		return nil, err
-	}
-
-	log, err := log.FindID(input.LogID)
-	if err != nil {
-		return nil, err
-	}
-
-	post, err := log.NewPost(postTime, input.Kind, input.Nick, input.Text)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Post", "add", user.ID, post.ID, map[string]interface{}{
-		"logId":    post.LogID,
-		"time":     post.Time,
-		"kind":     post.Kind,
-		"nick":     post.Nick,
-		"text":     post.Text,
-		"position": post.Position,
-	})
-
-	go log.UpdateCharacters()
-
-	return &types.PostResolver{P: post}, nil
-}
-
-// PostEditArgs is args for the editPost mutation
-type PostEditArgs struct {
-	Input *struct {
-		ID   string
-		Time *string
-		Kind *string
-		Nick *string
-		Text *string
-	}
-}
-
-// EditPost resolves the editPost mutation
-func (r *MutationResolver) EditPost(ctx context.Context, args *PostEditArgs) (*types.PostResolver, error) {
-	input := args.Input
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("post.edit") {
-		return nil, ErrUnauthorized
-	}
-
-	postTime := (*time.Time)(nil)
-	if args.Input.Time != nil {
-		t, err := time.Parse(time.RFC3339Nano, *input.Time)
-		if err != nil {
-			return nil, err
-		}
-
-		postTime = &t
-	}
-
-	post, err := log.FindPostID(input.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	err = post.Edit(postTime, input.Kind, input.Nick, input.Text)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Post", "edit", user.ID, post.ID, map[string]interface{}{
-		"time": postTime,
-		"kind": input.Kind,
-		"nick": input.Nick,
-		"text": input.Text,
-	})
-
-	go log.UpdateCharacters(post.LogID)
-
-	return &types.PostResolver{P: post}, nil
-}
-
-// PostMoveArgs is args for movePost mutation
-type PostMoveArgs struct {
-	Input *struct {
-		ID         string
-		ToPosition int32
-	}
-}
-
-// MovePost resolves the movePost mutation
-func (r *MutationResolver) MovePost(ctx context.Context, args *PostMoveArgs) (*types.PostResolver, error) {
-	input := args.Input
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("post.move") {
-		return nil, ErrUnauthorized
-	}
-
-	post, err := log.FindPostID(input.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	err = post.Move(int(input.ToPosition))
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Post", "move", user.ID, post.ID, map[string]interface{}{
-		"logId":       post.LogID,
-		"targetIndex": input.ToPosition,
-	})
-
-	return &types.PostResolver{P: post}, nil
-}
-
-// PostRemoveArgs is an arg
-type PostRemoveArgs struct {
-	ID string
-}
-
-// RemovePost resolves the removePost mutation
-func (r *MutationResolver) RemovePost(ctx context.Context, args PostRemoveArgs) (*types.PostResolver, error) {
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("post.remove") {
-		return nil, ErrUnauthorized
-	}
-
-	post, err := log.RemovePost(args.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Post", "remove", user.ID, post.ID, map[string]interface{}{
-		"logId": post.LogID,
-	})
-
-	go log.UpdateCharacters(post.LogID)
-
-	return &types.PostResolver{P: post}, nil
-}

graphql/resolver/root.go

@@ -1,13 +0,0 @@
-package resolver
-
-// The RootResolver brings queries and mutations together. The rest is just for readability.
-type RootResolver struct {
-	MutationResolver
-	QueryResolver
-}
-
-// The QueryResolver is the entry point for all top-level read operations.
-type QueryResolver struct{}
-
-// The MutationResolver is the entry point for all top-level mutation operations.
-type MutationResolver struct{}

graphql/resolver/session.go

@@ -1,39 +0,0 @@
-package resolver
-
-import (
-	"context"
-
-	"git.aiterp.net/rpdata/api/graphql/resolver/types"
-	"git.aiterp.net/rpdata/api/internal/session"
-)
-
-// LoginArgs is args
-type LoginArgs struct {
-	Username string
-	Password string
-}
-
-// Session resolves query.session
-func (r *QueryResolver) Session(ctx context.Context) (*types.SessionResolver, error) {
-	return &types.SessionResolver{S: session.FromContext(ctx)}, nil
-}
-
-// Login resolves mutation.login
-func (r *MutationResolver) Login(ctx context.Context, args *LoginArgs) (*types.SessionResolver, error) {
-	session := session.FromContext(ctx)
-
-	err := session.Login(args.Username, args.Password)
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.SessionResolver{S: session}, nil
-}
-
-// Logout resolves mutation.logout
-func (r *MutationResolver) Logout(ctx context.Context) (*types.SessionResolver, error) {
-	session := session.FromContext(ctx)
-	session.Logout()
-
-	return &types.SessionResolver{S: session}, nil
-}

graphql/resolver/story.go

@@ -1,329 +0,0 @@
-package resolver
-
-import (
-	"context"
-	"time"
-
-	"git.aiterp.net/rpdata/api/graphql/resolver/types"
-	"git.aiterp.net/rpdata/api/internal/session"
-	"git.aiterp.net/rpdata/api/model/change"
-	"git.aiterp.net/rpdata/api/model/story"
-)
-
-// StoryArgs is args for story query
-type StoryArgs struct {
-	ID string
-}
-
-// Story implements the story query
-func (r *QueryResolver) Story(ctx context.Context, args *StoryArgs) (*types.StoryResolver, error) {
-	story, err := story.FindID(args.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	return &types.StoryResolver{S: story}, nil
-}
-
-// StoriesArg is args for stories query
-type StoriesArg struct {
-	Filter *struct {
-		Author                *string
-		Tags                  *[]TagInput
-		EarliestFictionalDate *string
-		LatestFictionalDate   *string
-		Limit                 *int32
-	}
-}
-
-// Stories implements the stories query
-func (r *QueryResolver) Stories(ctx context.Context, args *StoriesArg) ([]*types.StoryResolver, error) {
-	filter := args.Filter
-
-	author := ""
-	if filter != nil && filter.Author != nil {
-		author = *filter.Author
-	}
-
-	tags := make([]story.Tag, 0, 8)
-	if filter != nil && filter.Tags != nil {
-		for _, tagInput := range *filter.Tags {
-			tags = append(tags, story.Tag{
-				Kind: tagInput.Kind,
-				Name: tagInput.Name,
-			})
-		}
-	}
-
-	earliest := time.Time{}
-	err := error(nil)
-	if filter != nil && filter.EarliestFictionalDate != nil {
-		earliest, err = time.Parse(time.RFC3339Nano, *filter.EarliestFictionalDate)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	latest := time.Time{}
-	if filter != nil && filter.LatestFictionalDate != nil {
-		latest, err = time.Parse(time.RFC3339Nano, *filter.LatestFictionalDate)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	limit := 30
-	if filter != nil && filter.Limit != nil {
-		limit = int(*filter.Limit)
-	}
-
-	stories, err := story.List(author, tags, earliest, latest, limit)
-	if err != nil {
-		return nil, err
-	}
-
-	resolvers := make([]*types.StoryResolver, len(stories))
-	for i, story := range stories {
-		resolvers[i] = &types.StoryResolver{S: story}
-	}
-
-	return resolvers, nil
-}
-
-// StoryAddArgs is args for the addStory mutation
-type StoryAddArgs struct {
-	Input *struct {
-		Name          string
-		Category      string
-		Author        *string
-		Open          *bool
-		Listed        *bool
-		Tags          *[]TagInput
-		FictionalDate *string
-	}
-}
-
-// AddStory implements the addStory mutation
-func (r *MutationResolver) AddStory(ctx context.Context, args *StoryAddArgs) (*types.StoryResolver, error) {
-	input := args.Input
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("member", "story.add") {
-		return nil, ErrUnauthorized
-	}
-
-	author := user.ID
-	if input.Author != nil {
-		author = *input.Author
-
-		if user.ID != author && !user.Permitted("story.add") {
-			return nil, ErrPermissionDenied
-		}
-	}
-
-	listed := (input.Listed != nil && *input.Listed == true)
-
-	open := (input.Open != nil && *input.Open == true)
-
-	tags := make([]story.Tag, 0, 8)
-	if input.Tags != nil {
-		for _, tagInput := range *input.Tags {
-			tags = append(tags, story.Tag{
-				Kind: tagInput.Kind,
-				Name: tagInput.Name,
-			})
-		}
-	}
-
-	fictionalDate := time.Time{}
-	if input.FictionalDate != nil {
-		date, err := time.Parse(time.RFC3339Nano, *input.FictionalDate)
-		if err != nil {
-			return nil, err
-		}
-
-		fictionalDate = date
-	}
-
-	story, err := story.New(input.Name, author, input.Category, listed, open, tags, time.Now(), fictionalDate)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Story", "add", user.ID, story.ID, map[string]interface{}{
-		"name":     input.Name,
-		"category": input.Category,
-		"author":   input.Author,
-	})
-
-	return &types.StoryResolver{S: story}, nil
-}
-
-// StoryTagAddArgs is args for the addStoryTag mutation
-type StoryTagAddArgs struct {
-	Input *struct {
-		ID  string
-		Tag TagInput
-	}
-}
-
-// AddStoryTag implements the addStoryTag mutation
-func (r *MutationResolver) AddStoryTag(ctx context.Context, args *StoryTagAddArgs) (*types.StoryResolver, error) {
-	input := args.Input
-	tag := story.Tag{Kind: input.Tag.Kind, Name: input.Tag.Name}
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("member", "story.edit") {
-		return nil, ErrUnauthorized
-	}
-
-	story, err := story.FindID(input.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	if story.Author != user.ID && !user.Permitted("story.edit") {
-		return nil, ErrPermissionDenied
-	}
-
-	err = story.AddTag(tag)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Story", "add.tag", user.ID, story.ID, map[string]interface{}{
-		"kind": tag.Kind,
-		"name": tag.Name,
-	})
-
-	return &types.StoryResolver{S: story}, nil
-}
-
-// StoryTagRemoveArgs is args for the removeStoryTag mutation
-type StoryTagRemoveArgs struct {
-	Input *struct {
-		ID  string
-		Tag TagInput
-	}
-}
-
-// RemoveStoryTag implements the removeStoryTag mutation
-func (r *MutationResolver) RemoveStoryTag(ctx context.Context, args *StoryTagRemoveArgs) (*types.StoryResolver, error) {
-	input := args.Input
-	tag := story.Tag{Kind: input.Tag.Kind, Name: input.Tag.Name}
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("member", "story.edit") {
-		return nil, ErrUnauthorized
-	}
-
-	story, err := story.FindID(input.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	if story.Author != user.ID && !user.Permitted("story.edit") {
-		return nil, ErrPermissionDenied
-	}
-
-	err = story.RemoveTag(tag)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Story", "remove.tag", user.ID, story.ID, map[string]interface{}{
-		"kind": tag.Kind,
-		"name": tag.Name,
-	})
-
-	return &types.StoryResolver{S: story}, nil
-}
-
-// StoryEditArgs is args for the addStory mutation
-type StoryEditArgs struct {
-	Input *struct {
-		ID            string
-		Name          *string
-		Category      *string
-		Author        *string
-		Open          *bool
-		Listed        *bool
-		FictionalDate *string
-	}
-}
-
-// EditStory implements the editStory mutation
-func (r *MutationResolver) EditStory(ctx context.Context, args *StoryEditArgs) (*types.StoryResolver, error) {
-	input := args.Input
-
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("member", "story.edit") {
-		return nil, ErrUnauthorized
-	}
-
-	story, err := story.FindID(input.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	if story.Author != user.ID && !user.Permitted("story.edit") {
-		return nil, ErrPermissionDenied
-	}
-
-	var fictionalDate *time.Time
-	if input.FictionalDate != nil {
-		date, err := time.Parse(time.RFC3339Nano, *input.FictionalDate)
-		if err != nil {
-			return nil, err
-		}
-
-		fictionalDate = &date
-	}
-
-	err = story.Edit(input.Name, input.Category, input.Listed, input.Open, fictionalDate)
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Story", "edit", user.ID, story.ID, map[string]interface{}{
-		"name":          input.Name,
-		"category":      input.Category,
-		"author":        input.Author,
-		"open":          input.Open,
-		"listed":        input.Listed,
-		"fictionalDate": input.FictionalDate,
-	})
-
-	return &types.StoryResolver{S: story}, nil
-}
-
-// StoryRemoveArgs is args for the removeStory mutation
-type StoryRemoveArgs struct {
-	ID string
-}
-
-// RemoveStory implements the removeStory mutation
-func (r *MutationResolver) RemoveStory(ctx context.Context, args *StoryRemoveArgs) (*types.StoryResolver, error) {
-	user := session.FromContext(ctx).User()
-	if user == nil || !user.Permitted("member", "story.edit") {
-		return nil, ErrUnauthorized
-	}
-
-	story, err := story.FindID(args.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	if story.Author != user.ID && !user.Permitted("story.remove") {
-		return nil, ErrPermissionDenied
-	}
-
-	err = story.Remove()
-	if err != nil {
-		return nil, err
-	}
-
-	go change.Submit("Story", "remove", user.ID, story.ID, nil)
-
-	return &types.StoryResolver{S: story}, nil
-}

graphql/resolver/tag.go

@@ -1,27 +0,0 @@
-package resolver
-
-import (
-	"git.aiterp.net/rpdata/api/graphql/resolver/types"
-	"git.aiterp.net/rpdata/api/model/story"
-)
-
-// TagInput resolves the TagInput input
-type TagInput struct {
-	Kind string
-	Name string
-}
-
-// Tags implements the tags query
-func (r *QueryResolver) Tags() ([]*types.TagResolver, error) {
-	tags, err := story.ListTags()
-	if err != nil {
-		return nil, err
-	}
-
-	resolvers := make([]*types.TagResolver, len(tags))
-	for i, tag := range tags {
-		resolvers[i] = &types.TagResolver{T: tag}
-	}
-
-	return resolvers, nil
-}

graphql/resolver/types/channel.go

@@ -1,39 +0,0 @@
-package types
-
-import "git.aiterp.net/rpdata/api/model/channel"
-
-// ChannelResolver for the Channel graphql type
-type ChannelResolver struct{ C channel.Channel }
-
-// Name resolves channel.name
-func (r *ChannelResolver) Name() string {
-	return r.C.Name
-}
-
-// Logged resolves channel.logged
-func (r *ChannelResolver) Logged() bool {
-	return r.C.Logged
-}
-
-// Hub resolves channel.hub
-func (r *ChannelResolver) Hub() bool {
-	return r.C.Hub
-}
-
-// EventName resolves channel.eventName
-func (r *ChannelResolver) EventName() *string {
-	if r.C.Event == "" {
-		return nil
-	}
-
-	return &r.C.Event
-}
-
-// LocationName resolves channel.locationName
-func (r *ChannelResolver) LocationName() *string {
-	if r.C.Location == "" {
-		return nil
-	}
-
-	return &r.C.Location
-}

graphql/resolver/types/chapter.go

@@ -1,50 +0,0 @@
-package types
-
-import (
-	"time"
-
-	"git.aiterp.net/rpdata/api/model/story"
-)
-
-// ChapterResolver for the Chapter graphql type
-type ChapterResolver struct{ C story.Chapter }
-
-// ID resolves Chapter.id
-func (r *ChapterResolver) ID() string {
-	return r.C.ID
-}
-
-// StoryID resolves Chapter.storyId
-func (r *ChapterResolver) StoryID() string {
-	return r.C.StoryID
-}
-
-// Title resolves Chapter.title
-func (r *ChapterResolver) Title() string {
-	return r.C.Title
-}
-
-// Author resolves Chapter.author
-func (r *ChapterResolver) Author() string {
-	return r.C.Author
-}
-
-// Source resolves Chapter.source
-func (r *ChapterResolver) Source() string {
-	return r.C.Source
-}
-
-// CreatedDate resolves Chapter.createdDate
-func (r *ChapterResolver) CreatedDate() string {
-	return r.C.CreatedDate.Format(time.RFC3339Nano)
-}
-
-// FictionalDate resolves Chapter.fictionalDate
-func (r *ChapterResolver) FictionalDate() string {
-	return r.C.FictionalDate.Format(time.RFC3339Nano)
-}
-
-// EditedDate resolves Chapter.editedDate
-func (r *ChapterResolver) EditedDate() string {
-	return r.C.EditedDate.Format(time.RFC3339Nano)
-}

graphql/resolver/types/character.go

@@ -1,45 +0,0 @@
-package types
-
-import "git.aiterp.net/rpdata/api/model/character"
-
-// CharacterResolver for the Character graphql type
-type CharacterResolver struct{ C character.Character }
-
-// ID is a property resolver
-func (r *CharacterResolver) ID() string {
-	return r.C.ID
-}
-
-// Nick is a property resolver
-func (r *CharacterResolver) Nick() *string {
-	if len(r.C.Nicks) == 0 {
-		return nil
-	}
-
-	return &r.C.Nicks[0]
-}
-
-// Nicks is a property resolver
-func (r *CharacterResolver) Nicks() []string {
-	return r.C.Nicks
-}
-
-// Name is a property resolver
-func (r *CharacterResolver) Name() string {
-	return r.C.Name
-}
-
-// ShortName is a property resolver
-func (r *CharacterResolver) ShortName() string {
-	return r.C.ShortName
-}
-
-// Author is a property resolver
-func (r *CharacterResolver) Author() string {
-	return r.C.Author
-}
-
-// Description is a property resolver
-func (r *CharacterResolver) Description() string {
-	return r.C.Description
-}

graphql/resolver/types/file.go

@@ -1,59 +0,0 @@
-package types
-
-import (
-	"time"
-
-	"git.aiterp.net/rpdata/api/model/file"
-)
-
-// FileResolver for the File graphql type
-type FileResolver struct{ F file.File }
-
-// ID resolves File.id
-func (f *FileResolver) ID() string {
-	return f.F.ID
-}
-
-// Author resolves File.author
-func (f *FileResolver) Author() string {
-	return f.F.Author
-}
-
-// Kind resolves File.kind
-func (f *FileResolver) Kind() string {
-	return f.F.Kind
-}
-
-// Time resolves File.time
-func (f *FileResolver) Time() string {
-	return f.F.Time.Format(time.RFC3339Nano)
-}
-
-// Public resolves File.public
-func (f *FileResolver) Public() bool {
-	return f.F.Public
-}
-
-// Name resolves File.name
-func (f *FileResolver) Name() string {
-	return f.F.Name
-}
-
-// MimeType resolves File.mimeType
-func (f *FileResolver) MimeType() string {
-	return f.F.MimeType
-}
-
-// Size resolves File.size
-func (f *FileResolver) Size() int32 {
-	return int32(f.F.Size)
-}
-
-// URL resolves File.url
-func (f *FileResolver) URL() *string {
-	if f.F.URL == "" {
-		return nil
-	}
-
-	return &f.F.URL
-}

graphql/resolver/types/log.go

@@ -1,117 +0,0 @@
-package types
-
-import (
-	"context"
-	"errors"
-	"time"
-
-	"git.aiterp.net/rpdata/api/graphql/loader"
-	"git.aiterp.net/rpdata/api/model/log"
-)
-
-// LogResolver for the Log graphql type
-type LogResolver struct{ L log.Log }
-
-// ID resolves Log.id
-func (r *LogResolver) ID() string {
-	return r.L.ID
-}
-
-// ShortID resolves Log.shortId
-func (r *LogResolver) ShortID() string {
-	return r.L.ShortID
-}
-
-// Date resolves Log.date
-func (r *LogResolver) Date() string {
-	return r.L.Date.Format(time.RFC3339Nano)
-}
-
-// ChannelName resolves Log.channelName
-func (r *LogResolver) ChannelName() string {
-	return r.L.Channel
-}
-
-// Channel resolves Log.channe
-func (r *LogResolver) Channel(ctx context.Context) (*ChannelResolver, error) {
-	loader := loader.FromContext(ctx)
-	if loader == nil {
-		return nil, errors.New("no loader")
-	}
-
-	channel, err := loader.Channel("name", r.L.Channel)
-	if err != nil {
-		return nil, err
-	}
-
-	return &ChannelResolver{C: channel}, nil
-}
-
-// Title resolves Log.title
-func (r *LogResolver) Title() string {
-	return r.L.Title
-}
-
-// Event resolves Log.event
-func (r *LogResolver) Event() string {
-	return r.L.Event
-}
-
-// Description resolves Log.description
-func (r *LogResolver) Description() string {
-	return r.L.Description
-}
-
-// Open resolves Log.open
-func (r *LogResolver) Open() bool {
-	return r.L.Open
-}
-
-// Characters resolves Log.characters
-func (r *LogResolver) Characters(ctx context.Context) ([]*CharacterResolver, error) {
-	loader := loader.FromContext(ctx)
-	if loader == nil {
-		return nil, errors.New("no loader")
-	}
-
-	chars, err := loader.Characters("id", r.L.CharacterIDs...)
-	if err != nil {
-		return nil, err
-	}
-
-	resolvers := make([]*CharacterResolver, 0, len(chars))
-	for i := range chars {
-		if chars[i].ID == "" {
-			continue
-		}
-
-		resolvers = append(resolvers, &CharacterResolver{C: chars[i]})
-	}
-
-	return resolvers, nil
-}
-
-// Posts resolves Log.posts
-func (r *LogResolver) Posts(ctx context.Context, args *LogPostArgs) ([]*PostResolver, error) {
-	var kinds []string
-	if args.Kinds != nil {
-		kinds = *args.Kinds
-	}
-
-	posts, err := r.L.Posts(kinds...)
-	if err != nil {
-		return nil, err
-	}
-
-	resolvers := make([]*PostResolver, len(posts))
-	for i := range posts {
-		resolvers[i] = &PostResolver{posts[i]}
-	}
-
-	return resolvers, nil
-}
-
-// LogPostArgs is an arg
-type LogPostArgs struct {
-	Kinds *[]string
-}

graphql/resolver/types/post.go

@@ -1,45 +0,0 @@
-package types
-
-import (
-	"time"
-
-	"git.aiterp.net/rpdata/api/model/log"
-)
-
-// PostResolver for the Post graphql type
-type PostResolver struct{ P log.Post }
-
-// ID resolves Post.id
-func (r *PostResolver) ID() string {
-	return r.P.ID
-}
-
-// LogID resolves Post.logId
-func (r *PostResolver) LogID() string {
-	return r.P.LogID
-}
-
-// Time resolves Post.time
-func (r *PostResolver) Time() string {
-	return r.P.Time.Format(time.RFC3339Nano)
-}
-
-// Kind resolves Post.logId
-func (r *PostResolver) Kind() string {
-	return r.P.Kind
-}
-
-// Nick resolves Post.nick
-func (r *PostResolver) Nick() string {
-	return r.P.Nick
-}
-
-// Text resolves Post.text
-func (r *PostResolver) Text() string {
-	return r.P.Text
-}
-
-// Position resolves Post.text
-func (r *PostResolver) Position() int32 {
-	return int32(r.P.Position)
-}

graphql/resolver/types/session.go

@@ -1,16 +0,0 @@
-package types
-
-import "git.aiterp.net/rpdata/api/internal/session"
-
-// SessionResolver resolves Session
-type SessionResolver struct{ S *session.Session }
-
-// User resolves Session.user
-func (r *SessionResolver) User() *UserResolver {
-	user := r.S.User()
-	if user == nil {
-		return nil
-	}
-
-	return &UserResolver{U: user}
-}

graphql/resolver/types/story.go

@@ -1,80 +0,0 @@
-package types
-
-import (
-	"time"
-
-	"git.aiterp.net/rpdata/api/model/story"
-)
-
-// StoryResolver for the Story graphql type
-type StoryResolver struct{ S story.Story }
-
-// ID resolves Story.id
-func (r *StoryResolver) ID() string {
-	return r.S.ID
-}
-
-// Author resolves Story.author
-func (r *StoryResolver) Author() string {
-	return r.S.Author
-}
-
-// Name resolves Story.name
-func (r *StoryResolver) Name() string {
-	return r.S.Name
-}
-
-// Category resolves Story.category
-func (r *StoryResolver) Category() string {
-	return r.S.Category
-}
-
-// Open resolves Story.open
-func (r *StoryResolver) Open() bool {
-	return r.S.Open
-}
-
-// Listed resolves Story.listed
-func (r *StoryResolver) Listed() bool {
-	return r.S.Listed
-}
-
-// Tags resolves Story.tags
-func (r *StoryResolver) Tags() []*TagResolver {
-	resolvers := make([]*TagResolver, len(r.S.Tags))
-	for i, tag := range r.S.Tags {
-		resolvers[i] = &TagResolver{T: tag}
-	}
-
-	return resolvers
-}
-
-// Chapters resolves Story.chapters
-func (r *StoryResolver) Chapters() ([]*ChapterResolver, error) {
-	chapters, err := r.S.Chapters()
-	if err != nil {
-		return nil, err
-	}
-
-	resolvers := make([]*ChapterResolver, len(chapters))
-	for i, chapter := range chapters {
-		resolvers[i] = &ChapterResolver{C: chapter}
-	}
-
-	return resolvers, nil
-}
-
-// CreatedDate resolves Story.createdDate
-func (r *StoryResolver) CreatedDate() string {
-	return r.S.CreatedDate.Format(time.RFC3339Nano)
-}
-
-// FictionalDate resolves Story.fictionalDate
-func (r *StoryResolver) FictionalDate() string {
-	return r.S.FictionalDate.Format(time.RFC3339Nano)
-}
-
-// UpdatedDate resolves Story.updatedDate
-func (r *StoryResolver) UpdatedDate() string {
-	return r.S.UpdatedDate.Format(time.RFC3339Nano)
-}

graphql/resolver/types/tag.go

@@ -1,16 +0,0 @@
-package types
-
-import "git.aiterp.net/rpdata/api/model/story"
-
-// TagResolver for the Tag graphql type
-type TagResolver struct{ T story.Tag }
-
-// Kind resolves Tag.kind
-func (r *TagResolver) Kind() string {
-	return r.T.Kind
-}
-
-// Name resolves Tag.name
-func (r *TagResolver) Name() string {
-	return r.T.Name
-}

graphql/resolver/types/user.go

@@ -1,16 +0,0 @@
-package types
-
-import "git.aiterp.net/rpdata/api/internal/session"
-
-// UserResolver resulves the user type
-type UserResolver struct{ U *session.User }
-
-// ID resolves User.id
-func (r *UserResolver) ID() string {
-	return r.U.ID
-}
-
-// Permissions resolves User.permissions
-func (r *UserResolver) Permissions() []string {
-	return r.U.Permissions
-}

graphql/schema/bindata.go

@@ -1,490 +0,0 @@
-// Code generated by go-bindata.
-// sources:
-// root.graphql
-// types/change.graphql
-// types/channel.graphql
-// types/chapter.graphql
-// types/character.graphql
-// types/file.graphql
-// types/log.graphql
-// types/post.graphql
-// types/session.graphql
-// types/story.graphql
-// types/tag.graphql
-// types/user.graphql
-// DO NOT EDIT!
-
-package schema
-
-import (
-	"bytes"
-	"compress/gzip"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"os"
-	"path/filepath"
-	"strings"
-	"time"
-)
-
-func bindataRead(data []byte, name string) ([]byte, error) {
-	gz, err := gzip.NewReader(bytes.NewBuffer(data))
-	if err != nil {
-		return nil, fmt.Errorf("Read %q: %v", name, err)
-	}
-
-	var buf bytes.Buffer
-	_, err = io.Copy(&buf, gz)
-	clErr := gz.Close()
-
-	if err != nil {
-		return nil, fmt.Errorf("Read %q: %v", name, err)
-	}
-	if clErr != nil {
-		return nil, err
-	}
-
-	return buf.Bytes(), nil
-}
-
-type asset struct {
-	bytes []byte
-	info  os.FileInfo
-}
-
-type bindataFileInfo struct {
-	name    string
-	size    int64
-	mode    os.FileMode
-	modTime time.Time
-}
-
-func (fi bindataFileInfo) Name() string {
-	return fi.name
-}
-func (fi bindataFileInfo) Size() int64 {
-	return fi.size
-}
-func (fi bindataFileInfo) Mode() os.FileMode {
-	return fi.mode
-}
-func (fi bindataFileInfo) ModTime() time.Time {
-	return fi.modTime
-}
-func (fi bindataFileInfo) IsDir() bool {
-	return false
-}
-func (fi bindataFileInfo) Sys() interface{} {
-	return nil
-}
-
-var _rootGraphql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x9c\x57\xcd\x6e\xeb\x38\x0f\xdd\xfb\x29\x18\x74\xd1\x14\x08\xf2\x00\xd9\xf5\xeb\xbd\xc5\x17\x20\x9d\xe9\x4c\x32\xab\xa2\xc0\x55\x6d\xc6\x26\xaa\x48\x1e\x51\x6e\x10\x5c\xdc\x77\x1f\x50\xf2\x8f\xec\x3a\x1d\x60\x76\xa6\x4c\x1e\x1e\x52\xf4\x61\x72\x03\x87\x0a\xe1\x8f\x06\xdd\x05\xfc\xa5\x46\x70\x58\x3b\x64\x34\x9e\xc1\x57\x62\xaa\x02\xd0\x78\x77\x81\xda\x92\x9c\x92\xf1\x36\xbc\xba\x7f\xde\xae\xb3\x10\x13\xc3\x7f\x66\x00\x37\xf0\x48\xa6\x80\xbc\x52\x4e\xe5\x1e\x1d\xbc\x5d\x00\xc9\x57\xe8\x40\x19\xd8\x7e\x03\xeb\x40\x81\xa1\xfc\x7d\x9d\xc1\xe0\xb6\xa4\x62\x03\x7b\xef\xc8\x94\xab\xf0\xb6\xb3\xee\x36\xf0\xd0\x39\x65\x33\xf8\x9c\x26\x00\x4d\xec\xc1\x1e\x81\x0a\x8e\x30\x1c\xf2\x19\x50\x8d\xaf\xac\x5b\xc3\xef\x46\x5f\xc0\x1a\x84\x5a\x39\x75\x42\x21\xa8\x3c\x28\xf0\x74\xc2\x94\x0f\x2f\xa9\xe0\x0d\xbc\x44\x12\x8b\xd7\x16\x6d\x74\x12\x31\x13\xa2\x2f\x3d\xd3\xc5\xeb\x22\x03\x18\xf3\x35\x06\xb5\x90\x35\xaa\x4b\x25\x27\x4b\x31\x3b\x8c\x45\xac\x56\xce\x93\x58\xa5\x75\xe7\xcd\x6b\xd8\xd7\x98\xd3\xf1\x42\xa6\x84\x1f\xda\x96\x25\x16\x1b\xf0\xae\xc1\x1f\xe0\x90\xbd\xa3\xbc\xbd\x37\x46\xe5\xf2\x0a\xbc\x05\x2b\x35\x47\xd7\xf5\x90\x98\x97\x5d\xf4\xff\xac\xd5\xa8\x4c\x5b\x80\xbc\x5b\xbc\x2e\x00\xc6\x05\x68\x5b\x0a\xf9\xed\xb7\x0c\xe4\x39\xb9\xaf\xbb\x0d\xec\x6c\x39\x76\xe5\xe8\xc5\xcb\x23\x69\x8f\x2e\x78\xf0\x63\x78\x96\x34\x3b\x5b\xfe\x1f\x55\x11\xfb\x94\x44\xd6\x96\x7d\xcc\x22\x44\xc5\x4a\xf2\x48\x73\x9e\x2d\xfb\x89\x3f\xc7\x00\x5e\xc3\xd6\xdf\x32\x9c\x50\x19\x2f\x55\x2b\xad\xed\x19\x6c\x18\x8c\x5a\x39\xcf\x32\x17\xd2\x98\xbf\xb6\xf2\x5a\x93\x79\x0f\x6e\x90\xeb\x86\x65\x0e\xec\x31\xe2\xad\x00\xd7\xe5\x1a\x8e\x61\x50\x9d\xb5\x27\x28\x90\x73\x47\xb5\x27\x6b\xc2\xb1\xaf\x30\x70\x78\x52\x75\x0d\x5c\xd9\x46\x17\x40\x1e\xf0\x43\xc6\x1d\x73\x7b\x42\x99\xa8\x8a\x4c\xb9\x86\x43\x45\x0c\x85\x45\x06\x63\x3d\x54\xea\x43\xde\xc5\xae\xac\x80\xc9\xe4\x08\x34\xe2\xfd\x86\xf0\x77\x83\x8e\xb0\x00\x32\x81\xb0\x34\xf2\x56\x6e\xb7\xb6\x86\xf1\x96\x81\x51\x63\x1e\xd8\x30\xfa\xae\x53\xd3\x89\x95\x76\xbd\x48\xbf\x26\x3d\x3e\x92\xc6\xfe\x26\xc5\x98\xb4\xf8\x91\x34\x76\xee\x1a\x19\x4a\xf4\x61\x02\xd5\x87\x22\xad\xde\x34\x86\x20\x69\xf7\x11\xc8\xe4\xba\x29\xf0\xb9\x79\xd3\x94\x03\x09\x33\xbf\x92\x56\x9c\x49\x6b\x70\xe8\x1b\x67\xa0\x8e\x6f\x43\x14\x28\x86\x33\x6a\xdd\xa6\xe6\xe5\x08\xa1\x1f\xc5\x15\x9c\xe8\x84\x87\x4b\x8d\x69\x45\x52\x90\x70\x9a\x14\xc4\xde\xba\x4b\x5f\x51\xb0\x26\x25\xed\xe5\x6c\x12\x41\xc8\xad\x37\xe1\x30\xa6\xfb\x68\x0f\x93\x1a\x42\x67\x13\xe6\x95\xaa\x5b\x7d\x0b\x89\x5b\x7b\x92\xfa\x21\x9e\x66\x93\xcf\xb9\x20\xf6\x64\x72\x0f\x5e\x95\x0c\x0d\xc7\xcb\x1e\x78\xc9\xf1\x06\x5e\x0e\xaa\x9c\xe4\xce\x1b\xe7\xd0\x78\x60\x64\x26\x6b\xa4\x84\xf8\xb4\x81\x7d\x7c\x58\x64\xbf\xb2\x2c\x8a\xfa\x53\xe3\x55\x18\x93\xa9\xae\x9f\x1d\x79\xfc\x57\x51\xef\xc3\xa3\xae\xdf\x17\x85\x28\x37\x9e\x07\x95\xcc\x00\x54\x51\x3c\x0c\x22\x6e\xea\xc6\x27\x82\x7d\x5f\x14\x5b\x39\x5a\xa4\x2a\xbe\xc8\x7a\x38\xd1\x54\x99\xf9\x6b\x80\xbf\x51\xfe\xfe\x09\x54\x0e\xe7\x50\x83\x62\xdd\xc0\x9f\x78\xb2\x1f\x18\xa1\x8f\xce\x9e\x46\xe0\x2e\xbc\xfc\x6f\xf8\x01\xfd\x7b\x41\x7e\x84\x88\x05\xf9\xeb\x0d\x10\xf7\xab\x58\x2d\x53\xf5\x15\xc3\xcf\xe3\xd4\x43\x24\x97\xd2\x4a\x7a\xdf\xbd\xb0\x58\x06\x2e\x62\x4e\xae\x22\xa8\x7c\x52\x52\x8a\xd1\x96\x34\x03\x32\x2d\x27\x41\x49\x8b\x69\x71\xfa\x52\xbe\xda\x73\xe3\x42\x64\xba\xb4\x2d\x63\x21\x3b\x59\x33\x31\xff\xce\x96\x69\x01\x3b\x5b\x8e\xc9\xc7\x18\x21\x3e\x0e\x1a\x11\x1e\xa2\x7a\xb2\x31\x2e\x12\xdd\x8d\xb6\xda\x10\x90\xd0\x13\x9d\x8d\xdc\x9e\xc3\x6e\x8a\x79\xee\xa3\xd9\xe7\x09\xa2\x3b\xa2\xd7\xc6\x09\xbf\x34\xf0\x7b\x6b\xcf\x45\x3e\x45\x82\x6d\xa4\xf0\x4b\x23\x9f\x5a\x7b\x2e\xb2\x2f\xae\x8d\x8d\xd5\x3d\xcf\x2f\xd3\xae\xbe\x96\xa8\x88\x72\x4b\xf4\x31\xac\x86\x81\xa8\xd8\x7d\xba\x20\xc3\x93\x74\x6d\x6c\x4c\xf7\x38\xbf\x58\xc6\xed\x0c\x42\x1a\xfb\xb9\x8f\xb2\x1d\xd3\x05\x23\xbd\xef\xa8\xc2\xdd\x17\x9e\x04\x8b\x50\x26\x00\x07\x55\x8e\x30\x0e\xaa\xbc\x0e\xd3\x13\x4f\x91\x22\xfb\x6b\x60\x31\xe4\x0a\x5e\xdb\xc2\xae\x28\xe9\xe1\xe7\xaa\x46\x03\xf9\x15\x9f\x31\x97\xb9\x85\xf6\x49\x02\xc2\x3a\x0a\x3f\x69\x92\xc6\x3e\x74\x6b\xa9\xff\x90\xeb\xcf\xc2\x5c\x4f\x04\xae\x87\x1b\xd4\x60\x06\x64\xaa\x06\xf5\xbc\xb4\xd5\x13\x61\xbb\xbe\x25\xbb\x8a\x76\xb6\x04\x32\xf1\x27\x24\x99\x65\xc3\xe8\x46\xea\xb1\x82\x5a\x31\x9f\xad\x1b\x37\xa5\xdb\x7f\x6d\x3f\x05\xc5\x36\x3e\xc2\xd8\xc6\x2f\xef\xc6\x3b\x92\xf3\x0a\x4f\x0a\x7e\x8a\xb7\xfc\xe2\xba\x6c\xe2\xdf\x18\xf9\xdc\xda\xcd\xb7\xe9\x77\x60\xf6\xeb\x9f\x00\x00\x00\xff\xff\x7a\x45\x45\x35\x28\x0d\x00\x00")
-
-func rootGraphqlBytes() ([]byte, error) {
-	return bindataRead(
-		_rootGraphql,
-		"root.graphql",
-	)
-}
-
-func rootGraphql() (*asset, error) {
-	bytes, err := rootGraphqlBytes()
-	if err != nil {
-		return nil, err
-	}
-
-	info := bindataFileInfo{name: "root.graphql", size: 3368, mode: os.FileMode(420), modTime: time.Unix(1531585622, 0)}
-	a := &asset{bytes: bytes, info: info}
-	return a, nil
-}
-
-var _typesChangeGraphql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x34\xcc\x21\xae\x02\x31\x18\x85\x51\xdf\x55\x7c\x2f\xcf\xb3\x00\x1c\x41\xb1\x8c\x9f\xe9\x85\x36\x90\xb6\x99\xde\x11\x13\xc2\xde\x09\x02\x7b\xc4\xf9\xe7\xc4\xb9\x44\xbb\x8b\x3a\x09\x46\xac\xa6\xdf\x70\x11\xa5\x4e\xf7\x75\xc7\x25\xcc\x12\x8d\xab\xd8\xa6\x32\xee\x3c\xa4\xc1\xf2\xac\x6a\x9e\x6c\xe3\x4b\x39\xac\x43\xf2\x3e\xf4\x1b\x5f\x09\x6a\x3e\x72\x69\xfe\x4b\xef\x4f\x00\x00\x00\xff\xff\xac\xbf\xc1\xe6\x6b\x00\x00\x00")
-
-func typesChangeGraphqlBytes() ([]byte, error) {
-	return bindataRead(
-		_typesChangeGraphql,
-		"types/change.graphql",
-	)
-}
-
-func typesChangeGraphql() (*asset, error) {
-	bytes, err := typesChangeGraphqlBytes()
-	if err != nil {
-		return nil, err
-	}
-
-	info := bindataFileInfo{name: "types/change.graphql", size: 107, mode: os.FileMode(420), modTime: time.Unix(1525610729, 0)}
-	a := &asset{bytes: bytes, info: info}
-	return a, nil
-}
-
-var _typesChannelGraphql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x90\x31\x4b\xc4\x40\x10\x85\xfb\xfd\x15\x4f\xae\xb0\xf1\x17\x5c\xa7\x87\x45\x1a\x0b\x15\x6c\x6f\x93\x9d\x64\x07\xf6\x66\x42\x76\x56\x10\xf1\xbf\x4b\xf6\x8c\xa7\x16\x72\x78\x95\x70\x55\xf2\xd8\x37\x8f\x8f\x6f\x85\x46\x7a\x9d\x76\xde\x58\x05\xbe\xd5\x62\xf0\x82\xe6\x7e\x83\x2e\x7a\x11\x4a\xce\x5e\x46\xc2\x66\x1f\xf0\xea\x80\x15\x1e\x23\x2d\xcf\x97\x19\xe2\x77\xe4\x50\x3f\x6b\x3c\xd8\xc4\x32\x5c\xb8\xda\x7b\x8a\x64\x91\x26\xd8\xa1\x8f\x1c\xb5\xa4\x80\x96\x90\x74\x18\x28\x38\x7c\xfc\xac\x71\xa3\x9a\xc8\xcb\x2f\xc7\x9c\xe1\x11\x4b\xfb\x09\x87\x39\xfd\xbc\x9c\xf1\xe8\x99\xc4\x2a\xd3\x15\x74\xc2\x56\x4a\x4a\x5b\x70\x0f\x51\xa1\x79\x27\x8f\xd4\x71\xcf\x15\xa0\x96\xef\xbe\xf0\x1f\x76\x92\x76\x7b\x37\x47\x4e\x2d\xfd\x6f\x6b\x6f\xce\xb1\x8c\xc5\x16\x8d\xd7\x21\x34\x35\x1f\xad\x13\x38\x41\xe8\x9f\x7d\xfe\x13\x9d\xb7\x81\xed\xec\xf3\x04\x9f\xef\x01\x00\x00\xff\xff\xed\x4a\x80\xd4\x06\x04\x00\x00")
-
-func typesChannelGraphqlBytes() ([]byte, error) {
-	return bindataRead(
-		_typesChannelGraphql,
-		"types/channel.graphql",
-	)
-}
-
-func typesChannelGraphql() (*asset, error) {
-	bytes, err := typesChannelGraphqlBytes()
-	if err != nil {
-		return nil, err
-	}
-
-	info := bindataFileInfo{name: "types/channel.graphql", size: 1030, mode: os.FileMode(420), modTime: time.Unix(1529172367, 0)}
-	a := &asset{bytes: bytes, info: info}
-	return a, nil
-}
-
-var _typesChapterGraphql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x84\x54\xb1\x6e\xdb\x30\x10\xdd\xf9\x15\xaf\xf0\x90\x25\x75\xf7\x6e\x41\x92\xc1\x53\x87\x04\xe8\x7c\x31\xcf\xd2\xa1\xd2\x51\x20\x4f\x36\x84\xa2\xff\x5e\x90\x94\xa3\x54\xb1\xdd\x49\xc2\xe9\xdd\xe3\xdd\x7b\x4f\xdc\xe0\x01\x8f\x2d\x0d\xc6\x11\x92\x60\x2d\xa3\x27\x51\xec\x83\x1a\xab\xe1\x2d\xf8\x09\xe1\x00\x42\xb2\x10\xa7\xad\xb3\x69\xe0\xf7\x8e\xdf\x0e\xd8\xe0\xb5\x65\xec\x6b\xe5\x2e\x61\xf7\xe4\x00\xf1\xdf\xf1\x62\x51\xb4\xf9\xe2\x2e\x60\x4c\xac\x63\x87\xfa\xbc\x89\xa4\xd1\xda\x10\x1d\xe6\x97\x9b\xd8\x14\xc6\xb8\xcf\xb4\xf5\x65\x85\xfd\xd9\xb2\x96\xfd\xe6\x06\x9c\x28\x61\x08\xc9\xd8\x43\x54\x4c\xa8\x9b\x1c\xb0\x8f\x4c\xc6\xfe\x89\xec\xd2\x60\xa2\x5f\x47\x95\x23\xc7\xc4\xf0\x64\x0c\x52\x0f\x93\x9e\xb3\x46\x1f\xc8\x1d\x70\x90\xbd\x49\x50\xea\xae\x50\x95\xf6\x70\x00\x7b\xb1\xad\x43\x79\xae\xcf\xfd\xe3\xdc\x06\x3b\x1d\x46\xc3\x21\x44\x90\xf7\x67\xe5\xfb\xd1\x28\xd3\x3b\x29\x5f\xe7\xf2\x83\xf7\x15\xbd\x18\x53\x6c\x83\x85\xdc\x0c\x7a\x5f\xde\x42\xd6\x29\x7f\xdb\x5d\xb2\xaa\x18\x93\xbb\x1a\x39\xf2\xc7\xc5\xb6\xd8\x19\xf6\xa4\xd0\x60\x78\x63\x74\x7c\x30\x70\x3f\xd8\x74\xc3\xce\xea\x5d\xa6\x4b\x5c\x37\x59\x33\x9e\xa4\xeb\x30\xa6\x7a\x54\x17\x9a\xa6\x98\x92\x2b\x11\xbb\xa7\xfb\x22\x73\xd0\x62\xd0\xa6\x54\x13\x4e\x62\x2d\x68\x18\x62\x18\xa2\x64\x2d\x07\x8e\xbd\xa4\x24\x41\x53\x99\x30\x7b\x0b\x4a\x20\x0d\xd6\x72\x9c\xa7\xd8\xe2\xf9\x58\x83\xa0\xf7\x10\xbb\x4b\x0b\x6f\x1e\x4c\xfa\x21\x44\x13\x6d\xbe\xf5\xe1\x28\xda\x9c\x7f\x84\x2d\x5e\x5b\x39\xc7\x11\x4a\x3d\xd7\x99\x67\x19\xc6\xc4\x1e\xa7\x9c\xb0\x3c\x7c\xee\xcb\x8b\x14\xd6\x34\xbe\xcd\x63\x7d\x4a\xf1\xa2\x50\x4f\xf1\x97\x0f\x27\x9d\xa3\xbb\x68\x54\x4f\xbf\x96\xe9\x1f\x43\x8d\x58\x37\xdd\x83\x52\x92\x46\x41\x4b\xf0\x6a\xc4\x56\x72\x5f\x4b\xe6\x3a\x6b\x39\x8e\xb7\xc3\xf6\xec\xc5\xd6\x69\x5b\xe2\x55\x08\x2e\xdd\x04\x8f\x2d\x69\xf3\x4f\xa6\xae\x5d\x08\x9f\xf0\x57\x7e\xf0\x8a\x7b\x61\x2b\xa0\x0b\xeb\xd3\xff\x97\xff\x1b\x00\x00\xff\xff\x48\xf2\x61\xf4\x08\x05\x00\x00")
-
-func typesChapterGraphqlBytes() ([]byte, error) {
-	return bindataRead(
-		_typesChapterGraphql,
-		"types/chapter.graphql",
-	)
-}
-
-func typesChapterGraphql() (*asset, error) {
-	bytes, err := typesChapterGraphqlBytes()
-	if err != nil {
-		return nil, err
-	}
-
-	info := bindataFileInfo{name: "types/chapter.graphql", size: 1288, mode: os.FileMode(420), modTime: time.Unix(1530984073, 0)}
-	a := &asset{bytes: bytes, info: info}
-	return a, nil
-}
-
-var _typesCharacterGraphql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x94\x54\xbd\x72\xdc\x3c\x0c\xec\xf5\x14\xeb\x71\xf1\x35\xb6\xbf\xde\xdd\xc5\x4e\xe1\xc6\xc9\x38\xee\x32\x29\x60\x11\x3a\x61\x4c\x91\x0a\x01\xda\xa3\x78\xee\xdd\x33\x94\xee\xcf\x3a\x5d\x91\xee\x8e\x5c\x2c\x80\xdd\xa5\x2e\xb1\xc2\x5d\x4b\x89\x6a\xe3\x84\xc4\x7d\x62\xe5\x60\x0a\x0a\x78\xfa\x8e\x7a\x77\x55\xd9\xd0\xf3\x11\xf2\xa3\x02\x4a\x6d\x0e\xf2\x3b\x33\xc4\x71\x30\x69\x84\x13\x9a\x98\x60\x2d\x1f\x95\x02\xe2\x6e\xf1\xc3\x92\x84\xf5\x45\x35\x16\x3e\xb7\x8c\x3e\x49\x47\x69\xc0\xc3\xd3\x1d\x82\xd4\xaf\x78\x61\x1f\xc3\x5a\xc2\x1a\x16\x4f\x28\x0a\x62\x47\x32\x71\xac\xbc\xdf\xd7\x2a\x48\x35\xd6\x42\xc6\x0e\xef\x62\x2d\xac\x15\x3d\x21\xd0\x5b\xfc\xdc\xce\xf1\xeb\x68\x92\x3d\xec\x3f\x05\x65\x6b\x63\xc1\x4f\x3f\x16\xe6\x3e\x46\x07\xea\xb8\x70\x53\xc7\x0b\xc8\x72\x5c\x76\x71\xa2\xbd\xa7\x01\xef\x2d\x07\x68\x4f\x35\x43\x14\x5a\x53\xaa\xf9\x0a\x59\x33\x79\x3f\x8c\x1b\x37\x92\xd4\xfe\x5f\xcb\x1b\x87\x1d\xb7\xb6\x31\xd9\xe3\x69\x83\xd5\x74\x03\xc7\x5a\x27\xe9\x4d\x62\x40\x6c\x4e\x74\x3b\xba\x3e\x10\x6c\xaa\xea\x12\x0f\xa1\xcf\x36\xda\x45\xce\x15\xd5\xf7\x65\x5a\xc9\x78\xb7\xb7\x7b\xe5\xdc\x84\xfe\x38\xef\xde\x6e\xd9\xc4\x75\x5c\x07\xf9\xc3\x33\x0b\xf0\x32\xcc\x6c\xfc\x67\x4d\xbf\x95\x35\x28\xf8\x69\x73\x0e\xec\x46\xd4\x0d\xbe\x0c\x70\xdc\x50\xf6\x76\x05\x31\x64\x65\x3d\xc8\x09\x8b\xaf\x1c\x20\x61\x3c\x3a\xa7\xea\xd4\xe1\xfe\x48\xcc\x51\x99\xc3\x64\x37\xcb\x62\x7e\x9e\xcc\x0f\x57\xd0\x9e\x6b\x69\x06\x50\x88\xd6\x72\xda\x06\xe9\x06\xcf\x45\x8e\xc0\xec\x74\x82\x90\x47\xcf\xa9\x13\x55\x89\x41\x21\x0d\xc4\xca\xfa\xd1\x46\xca\x21\xe6\x84\xf8\x1e\xca\x36\x69\x3b\xf5\xe7\x4c\x2e\xd8\xf8\x58\x9c\xa0\xe0\x90\xb8\x8b\x6f\x3c\xfe\xed\xb2\x51\x99\x78\x6e\x6a\xb9\x9c\xbb\xfa\x70\xbf\x94\xa1\xc5\xe7\x3b\x9a\x6e\xb1\x74\x45\x4c\xdb\x86\x27\x0e\x6f\xaa\x79\xdb\xaf\x4e\x6c\xde\x56\xdc\xe9\x67\xa3\x70\xb3\x13\x3b\xd7\xbf\xc9\xde\x4f\xa1\x9b\x4f\x8c\xeb\xeb\xa2\xe2\x78\xa8\xe4\x29\x09\x85\x03\xfc\x62\x96\xad\xe5\x10\x4e\x6f\x6b\xca\x74\x4b\x56\xde\x6b\x56\x76\x25\x45\x75\xec\x7a\xaa\x0d\x5e\xd4\xf4\x7c\x94\x96\xde\xe7\xd2\xb7\x71\x29\x53\x9b\xbf\x01\x00\x00\xff\xff\x54\xc3\xda\x87\x97\x05\x00\x00")
-
-func typesCharacterGraphqlBytes() ([]byte, error) {
-	return bindataRead(
-		_typesCharacterGraphql,
-		"types/character.graphql",
-	)
-}
-
-func typesCharacterGraphql() (*asset, error) {
-	bytes, err := typesCharacterGraphqlBytes()
-	if err != nil {
-		return nil, err
-	}
-
-	info := bindataFileInfo{name: "types/character.graphql", size: 1431, mode: os.FileMode(420), modTime: time.Unix(1526204279, 0)}
-	a := &asset{bytes: bytes, info: info}
-	return a, nil
-}
-
-var _typesFileGraphql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\x52\xb1\x8e\x13\x31\x10\xed\xfd\x15\x8f\x4b\x41\x73\xca\x07\xa4\x03\x71\x48\x91\x48\xc3\x1d\xa2\xf6\x9e\x67\xe3\x51\x6c\xcf\x62\x8f\xb3\x0a\xa7\xfb\x77\x64\xef\x1e\x8a\x50\x0a\xe8\xa8\x56\x3b\x7e\xef\xcd\x9b\x37\xb3\xc1\x07\x7c\xe6\x40\x78\x96\xa4\x96\x53\x01\xa7\x51\x72\xb4\xca\x92\x60\x07\xa9\x0a\x8b\xb1\x21\x6c\x72\x98\x3d\x65\x82\x0a\x9c\xcc\x29\x88\x75\x60\xdd\x1a\xbd\x4c\xb4\xa8\xbc\x18\x60\x83\x27\x4f\x9d\xf2\xbe\xa0\x26\xfe\x51\x09\xfb\x4f\x06\x60\xb7\xc3\xa3\x66\x4e\xc7\x77\xe6\x37\xee\xc4\xc9\x41\xc6\x8e\xdf\xe2\x20\x45\x31\x73\x08\x18\x08\x77\x75\x6a\x2d\xee\xee\x31\x54\x45\x91\x48\x50\x6f\x15\x36\x13\x26\xc9\x4a\x0e\x63\x96\x08\xf5\x84\x99\x4f\xbc\x10\xbd\x3d\x13\x44\x3d\x65\x9c\x6d\xa8\x54\x30\x4a\x86\x7a\x2e\x5b\x83\xde\xee\x86\x0b\xe5\x48\xcd\xc5\xd2\x91\xd3\xd1\xa0\xd7\xfe\x80\x7e\xf7\xd4\x85\x75\x1d\x10\x5c\x30\xd5\x21\xf0\x73\xb8\x20\x70\x51\x3b\xb4\x29\x1e\x25\x92\xa4\x66\x4a\x3d\x4e\x49\xe6\x40\xee\xd8\xf5\x1b\xb1\x67\xb1\x59\xcc\x16\x5d\x67\x6d\xc4\x96\xeb\x99\x69\x06\xeb\x3d\xbc\xcc\x74\xa6\xdc\x3c\x2f\x1d\x76\xf8\x28\x12\xc8\xa6\x2b\xdb\x6b\xc8\xc9\x46\x32\xe8\x9f\x1b\xb3\x1d\xf6\x87\x07\xf4\x15\xad\x06\x1a\xcb\x00\x91\x23\x3d\x5d\xa6\x5b\x94\x55\xb7\xf0\x4f\x02\x27\x0c\x17\xa5\x62\xd0\xff\x77\xd8\x27\xbd\x82\x2e\x89\x51\x36\x80\xad\xea\x25\xdf\x90\xfb\xf6\xf5\xcb\xdb\xe5\x5c\x05\xe7\xa5\x28\x39\x03\xd4\x1c\xde\x48\xe6\xd5\x98\x0d\xf6\x69\xaa\xda\xd7\x46\x8e\xb5\x1f\x56\xac\xda\x4f\xd2\x70\x7f\x7b\x58\xeb\x0b\xf2\xc5\xfc\xc3\xd1\xfd\x17\x3b\xfc\x9b\x15\x9a\xd7\x5f\x01\x00\x00\xff\xff\xe4\xc2\x5b\xa8\x9d\x03\x00\x00")
-
-func typesFileGraphqlBytes() ([]byte, error) {
-	return bindataRead(
-		_typesFileGraphql,
-		"types/file.graphql",
-	)
-}
-
-func typesFileGraphql() (*asset, error) {
-	bytes, err := typesFileGraphqlBytes()
-	if err != nil {
-		return nil, err
-	}
-
-	info := bindataFileInfo{name: "types/file.graphql", size: 925, mode: os.FileMode(420), modTime: time.Unix(1528836115, 0)}
-	a := &asset{bytes: bytes, info: info}
-	return a, nil
-}
-
-var _typesLogGraphql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xec\x56\xc1\x6e\xdc\x46\x0c\xbd\xeb\x2b\x98\xf8\xe0\x04\x48\xd3\x83\x4f\xdd\x9b\x6b\x24\xa8\x81\xa0\x0d\x92\x00\x3d\x18\x39\xcc\x6a\xb8\x2b\x22\x23\x52\x99\xa1\x76\xb3\x08\xf2\xef\x05\x29\xc9\x5e\x29\x5b\x64\xd1\x43\x91\x83\x4f\x9e\x1d\x93\x8f\xe4\x23\xf9\x46\x17\x70\x0d\x6f\x64\x0b\x54\x40\x1b\x84\xa7\x1b\x4a\xf8\x14\x64\x03\x81\xe1\xdd\x5b\x28\x58\x0a\x09\x57\x7a\xe8\xd0\xed\xbe\x56\x00\xe6\xd3\x33\x7d\xee\x11\x28\x22\x2b\x6d\x08\x33\x6c\x24\x3b\x44\x92\xed\xcb\x0a\x80\xe2\x0a\xde\x6b\x26\xde\x3e\xa9\x46\x9f\x82\xb5\x70\x0c\xf9\xf0\x03\x6f\xf8\xd0\x50\xb1\x8c\x02\x24\x51\x28\x8d\x64\xc5\x0c\x81\x23\xb4\x92\x11\x4a\x4f\x1a\xd6\x09\xdd\xa9\xa8\xe4\xb0\x45\xd8\x37\xc8\x1e\xc7\x51\x88\x3f\x41\x14\x2c\x7c\xa9\xc0\x88\x11\x54\x60\x8d\x10\x0a\xe0\x97\x2e\x5b\x51\x3b\xb4\x2c\x1d\xfb\x76\x99\xea\x87\x06\x21\x06\x1d\x02\x84\xa9\x22\xbb\x39\x61\x58\x37\x81\x19\x93\x73\x36\x99\x8e\x77\x7f\x86\x76\xe9\x71\xcb\x1b\xc9\x6d\x50\x12\x86\xb0\x96\x5e\x3d\xdf\x09\x43\xad\xf0\x34\xb4\x83\xf8\x08\x69\x05\x37\xc3\xe1\x28\xf0\xd8\x9b\xcb\x02\x4a\x9a\xbc\x1c\x3f\x9c\xc8\x31\xc9\xf6\xb2\x00\xee\x90\xf5\x05\xec\x1b\xaa\x9b\xa9\xe1\x25\xb4\x4e\x8b\x9d\x35\x6c\x2d\xac\x9f\xbb\x8c\x3b\x92\xde\xb3\x59\x5b\x13\x48\x3d\xc2\x05\xbc\x6a\x3b\x3d\x40\xf1\x10\xd0\x62\x60\x73\x0e\x0a\xa4\x97\x05\x58\x86\x28\x66\xea\x87\x53\xcc\x62\xa9\x33\x75\x4e\x81\x93\x36\x16\x72\x94\x19\x7a\x0c\xda\x40\xcf\x05\x1d\xec\xc8\x69\x01\xf9\x77\x83\xda\xe0\xfd\xf4\x4c\x68\x06\x23\x1d\x3a\x89\xf6\x77\x05\xbf\x8b\x24\x0c\x3c\x6f\x5d\x0e\xb5\x62\xb6\xb2\x77\x92\x76\x18\xa7\xfa\x0d\xc9\x76\x61\xec\xc1\x68\xb6\x82\xbb\x9b\xe9\xc7\x93\x8f\x47\x48\x9d\x14\x2d\x56\xcd\xe8\x6b\xae\x53\x3d\x75\x60\x9b\xbd\x0d\x25\xc5\x8c\x11\xd6\x07\xf8\x44\x1c\x8b\x41\xbb\xdf\x33\xff\xb9\xba\x1b\xcb\xfa\xf8\x7c\x05\x77\x6f\xa5\xa8\x45\xf8\x56\x55\x17\xf0\xda\x5d\x7d\x1a\x93\x6c\x0b\x7c\xee\x31\x1f\x2a\xe2\xae\x57\x5b\xca\x32\xfe\x7f\xd8\xcd\x71\x50\x8a\x8d\x7c\xa2\x96\x14\x32\x96\x3e\xa9\x5f\x3c\x23\xae\x53\x6f\xd3\xff\xfc\x61\xb8\xac\xac\x29\x76\x05\x30\x74\xd9\x9a\x77\x0e\x86\x77\x79\x86\x30\x65\x31\x51\x7b\x12\x03\xbf\xcc\xf3\x78\x20\x78\x8e\xf3\x1e\x43\xae\x1b\xe7\x09\x6a\x61\x45\x56\x5b\x5b\xbf\x9d\x06\x61\xb0\x7c\xe3\x31\x54\x40\x38\x1d\xbc\xe5\x4e\xd6\xb2\xfd\x33\xe3\x06\x21\xb4\xd2\xb3\x5a\xeb\xbc\x17\x15\x0c\xc9\xae\xe0\x96\x75\x60\xff\xd6\x79\x76\x29\x88\xd1\x34\xb0\xed\xd5\x17\xf8\xa1\x03\xd7\x31\x0e\x56\x5f\xe7\xfa\xf1\x30\x10\x2f\x6c\xb0\xde\xbd\xbe\xb9\xba\xba\xfa\x0d\x06\x09\x80\x3d\x69\x03\x7d\x67\x39\x73\x60\x19\xe4\xd1\x36\xaf\x26\x17\xdd\x1f\x4a\xce\xbe\xc1\x8c\xf7\xe3\x4a\x05\x0a\xea\xb1\x66\xcc\x1c\xff\xf2\xe5\x09\x69\x35\x29\xc2\xa0\x16\x4b\xd5\x58\x1a\x2f\xd7\x6b\x5c\xab\xd3\xb4\x7e\x1f\xc3\xc7\x03\x38\xb4\xb8\x54\x84\xa5\xc7\xf5\x20\xc6\x4b\x79\x18\xe3\x9e\x96\x80\xb3\x1b\xf4\x2a\x92\x2e\x3b\x44\x71\x8e\xff\xdd\x8b\x75\x06\x4f\xe7\x96\xf9\x9f\x8a\x1b\x09\x42\xfe\xb5\x4e\x52\xf0\xc8\x7a\x4e\xbd\x93\xe0\xcf\xf8\x1f\x18\x22\xe6\xe1\xe9\xac\x7b\xfd\x25\xca\x9e\x61\x87\xb9\x8c\xf1\x8c\x1c\x17\x6b\x7b\x1b\x81\x45\x21\xa4\x24\x7b\xd8\xa2\xaa\xc9\xb9\x2f\x44\xad\x7d\x48\xc3\x36\xbc\xbc\x7f\xf8\x47\xe4\xc7\xe7\xff\xdf\x76\xd1\x7a\xff\xbf\x7d\x03\x8c\x22\xfd\xf8\x15\xf0\x53\x7c\x05\x7c\xab\xfe\x09\x00\x00\xff\xff\xd3\x31\x19\xf7\x46\x0b\x00\x00")
-
-func typesLogGraphqlBytes() ([]byte, error) {
-	return bindataRead(
-		_typesLogGraphql,
-		"types/log.graphql",
-	)
-}
-
-func typesLogGraphql() (*asset, error) {
-	bytes, err := typesLogGraphqlBytes()
-	if err != nil {
-		return nil, err
-	}
-
-	info := bindataFileInfo{name: "types/log.graphql", size: 2886, mode: os.FileMode(420), modTime: time.Unix(1531585338, 0)}
-	a := &asset{bytes: bytes, info: info}
-	return a, nil
-}
-
-var _typesPostGraphql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xd4\x54\xc1\x6a\xdc\x40\x0c\xbd\xfb\x2b\x5e\x36\x87\xbd\x6c\x73\xc9\xa9\xb9\x85\xa6\x05\x43\x4b\x97\x34\x3f\x30\x99\xd1\x7a\x86\xb5\x25\x33\x92\x93\x2c\xa5\xff\x5e\x66\xbc\x21\x10\xbc\x87\x96\x04\xda\x93\x41\x7a\xa3\xf7\xa4\xf7\xf0\x39\xae\xb1\x15\x35\x24\x85\xc3\xe8\xb2\x41\x76\x70\xe8\xa5\x6b\xec\x30\xd2\xdc\xfc\xd9\x00\xe7\xb8\x8b\x84\x51\xd4\xd6\x8a\xf6\xa6\x01\x52\xb8\xc2\x0f\xcb\x89\xbb\xb3\xe6\x35\xe0\xab\x74\x68\x6f\x2e\x70\x17\x93\x96\xd9\x16\x09\xbe\x17\x25\x35\x58\x4c\xdc\xc1\xa4\xd0\x24\xde\xe3\xde\xf9\x3d\x34\xb1\xa7\xd2\x52\x5c\x6f\x5b\x74\xd9\x8d\x11\x41\x48\x79\x6d\x88\xee\x81\xe0\xf8\x00\x7f\xf0\x3d\xe9\x45\x83\x22\xb0\x5d\xe2\x0f\xce\x0a\x34\xc0\xd2\x40\x65\x97\x22\x28\x71\xd7\xa0\x56\x16\x5e\xec\x13\x87\x67\xe0\x2c\x20\xe9\x05\xbe\x73\x7f\xc0\xca\xe8\xc9\x56\x1b\xac\xd4\x13\xd3\xaa\xce\x5d\x39\x6f\x49\x78\x05\x97\x09\xb7\xdb\x0d\x1e\x63\xea\x09\x62\x91\xb2\xd6\xa2\x63\x16\x73\x05\xa4\xf5\xc5\xda\xcb\x30\x38\x0e\xba\x2e\xc2\x0b\xdd\x82\x0a\x1f\x5d\x76\xde\x28\x83\x93\xdf\x37\xa8\x9f\xd3\xf7\x2d\xc2\x2a\xb5\x8f\x18\xa7\x3c\x8a\x12\x02\x8d\xc4\x41\x21\x5c\xcf\x5d\x88\xca\xd6\xf4\x64\xa7\xe7\x8c\xa2\xa9\x28\xdd\x60\x52\x0a\xd8\x49\x46\x26\xc9\x81\xf2\x7c\xb3\xe7\xfe\x15\x5a\xb6\xb3\xe6\x57\xd3\x9c\xa3\xe5\x71\xb2\x0a\x2d\x34\x2e\x84\x9a\x91\x61\x9a\x77\x6e\x52\x6d\x5f\xcf\xe5\x19\xfb\x92\x9f\x5e\xba\x1a\x1f\x58\x74\xc7\x6b\xd7\xbb\x6b\x94\xa9\x0f\xb8\xa7\x97\x14\xfe\x85\xc9\x1b\x24\x86\xc3\xed\x97\x4f\x97\x97\x97\x1f\x8b\xc4\xc1\x19\x1e\x93\x45\x4c\xe3\x9c\x38\x76\x2c\x4a\x5e\x38\x94\xed\x33\xf9\xa4\x45\xf4\x7f\x95\x8e\x0d\x24\xe3\xf8\x0c\x89\x1f\x64\x4f\xb9\xfa\xc1\xc2\x1f\x6e\xb7\x50\x9b\x76\xbb\x77\x8b\xd0\x42\x06\x28\x24\x5b\x0a\xc1\xe7\x63\xfd\x75\x0a\x2a\xf6\xf4\x3f\xe4\xbd\xed\xfd\x27\xdc\x7d\x4b\x73\xdf\xc8\xdb\x25\x6b\x07\x79\xa0\x25\x6b\xbf\x1d\xeb\x7f\x62\xad\xcb\x1d\x19\x12\x07\x7a\x2a\xcc\xb2\x7d\xf5\x73\xf9\x1d\x00\x00\xff\xff\x60\x35\xc5\x5a\x8d\x06\x00\x00")
-
-func typesPostGraphqlBytes() ([]byte, error) {
-	return bindataRead(
-		_typesPostGraphql,
-		"types/post.graphql",
-	)
-}
-
-func typesPostGraphql() (*asset, error) {
-	bytes, err := typesPostGraphqlBytes()
-	if err != nil {
-		return nil, err
-	}
-
-	info := bindataFileInfo{name: "types/post.graphql", size: 1677, mode: os.FileMode(420), modTime: time.Unix(1530961143, 0)}
-	a := &asset{bytes: bytes, info: info}
-	return a, nil
-}
-
-var _typesSessionGraphql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x44\xcc\x4b\x0a\x02\x31\x10\x06\xe1\x7d\x4e\x51\xe0\xd6\x13\x78\x0d\xf5\x00\x83\xfe\x4e\x02\xa1\x33\x74\x77\x16\x22\xde\x5d\x7c\x80\xdb\xe2\xa3\x76\x9c\xaa\x08\x45\xb4\x61\xb8\x36\x57\xc8\x32\xc8\x2a\x2e\xd3\x5d\x96\xf4\xb1\x36\x23\x72\x49\x95\xbc\x6f\xe2\xf8\xf3\x8f\x02\xdf\xc3\x0c\x39\x59\x97\xa4\xc5\xdb\xaf\xba\xd2\x6c\x8f\xcd\xde\x69\x37\x6c\xe4\x3f\x17\x3e\xfe\xc0\x39\xe4\xe5\xf9\x0a\x00\x00\xff\xff\x3a\x24\x24\xaf\x84\x00\x00\x00")
-
-func typesSessionGraphqlBytes() ([]byte, error) {
-	return bindataRead(
-		_typesSessionGraphql,
-		"types/session.graphql",
-	)
-}
-
-func typesSessionGraphql() (*asset, error) {
-	bytes, err := typesSessionGraphqlBytes()
-	if err != nil {
-		return nil, err
-	}
-
-	info := bindataFileInfo{name: "types/session.graphql", size: 132, mode: os.FileMode(420), modTime: time.Unix(1525515204, 0)}
-	a := &asset{bytes: bytes, info: info}
-	return a, nil
-}
-
-var _typesStoryGraphql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xd4\x57\x4f\x6f\xe3\xb6\x13\xbd\xeb\x53\x4c\x90\xc3\xee\x02\x81\x7f\x3f\x20\xa7\xfa\x96\x4d\x9a\xc2\x97\x62\x91\x04\xe8\x61\xb1\x87\xb1\x38\x96\xd8\x50\xa4\x96\x1c\xc6\x35\x82\xfd\xee\xc5\x90\x94\x64\x3b\xb2\xd3\x43\x0b\xb4\x17\xc3\x12\x87\xf3\xf7\xbd\x47\xea\x12\x6e\xe0\x91\x9d\xdf\x81\x0e\x80\xd0\x6b\xaa\x09\xdc\x06\x6a\x67\x99\x2c\x03\xb7\xc8\x57\x10\xad\xd1\xcf\x04\x5b\xfd\xac\x01\x3d\xeb\xda\x50\xb8\x02\xf4\x04\xd6\x31\x04\xd7\x11\xb7\xda\x36\xc9\x1a\x42\xeb\xa2\x51\xb0\x26\x70\x5e\x91\x27\x05\xeb\x1d\xb0\xee\x08\xb4\x0d\x4c\xa8\xc4\x3f\x6b\x36\xb4\x80\x15\x43\x8d\xb6\xba\x4c\xf1\x50\x5b\xe8\xa2\x61\xdd\x1b\x82\xba\xc5\x9e\xc9\x07\xd9\xec\xac\xf8\x82\xce\x79\x02\x8c\xec\x5a\x1f\x2a\xde\xf5\x54\x32\x7f\xad\x00\x2e\xe1\xa9\x25\x08\xf2\xfc\x21\xc0\xea\xae\x02\xd0\x6a\x09\x8f\xec\xb5\x6d\x2e\xaa\x37\x16\x16\x3b\xba\x82\x6d\xab\xeb\x16\xb6\xda\x18\xc9\x7a\x0b\xb1\x07\x6d\x81\x5b\x02\xa3\x03\x87\x45\x05\xc9\xf0\x8c\x1f\x8c\xdc\x3a\x5f\x41\xf9\x73\x64\xf9\x5b\x4b\xdc\x92\x07\x97\x7e\x63\x90\x7a\x3a\xdc\x01\x2a\xf5\x3f\x52\x9a\xa7\x2a\xd9\xa5\xb0\xc9\xad\x84\x75\x3d\xd9\x25\x7c\x76\xce\x10\xda\x23\x6f\xd9\xcf\x56\x73\xeb\x22\x03\x82\xd2\x9e\x6a\x06\xa3\xed\xb3\x74\x13\x36\xda\x2a\xe0\x56\x87\xc9\x9d\x94\x43\xea\xd8\xa1\x14\x52\x23\x53\x23\x5d\x94\xa1\x0c\x19\x54\x30\xbe\x5f\xe6\x26\xdf\x96\xc7\xbd\x9d\x8c\x4d\x80\x8d\xf3\x39\x54\xd9\x26\x2f\x97\xf0\xf5\x09\x9b\x8b\x6f\xfb\x51\x86\x3a\x53\x94\x21\x33\x09\x53\x16\x96\xf0\xf5\x36\xff\x3d\xd8\xa7\x90\x69\x4a\x0b\xb6\x18\xa0\xf6\x84\x4c\x0a\x3e\x3e\xdc\xdf\x5e\x5f\x5f\xff\x24\x29\x74\xc8\x9f\xa4\xcc\xb2\x76\x87\x3c\x37\xb3\x23\x67\x92\x05\xb1\x0c\x7c\xce\xd5\x46\xd7\xac\x9d\x45\x73\xce\x59\xe9\x99\xc1\xc0\xd0\xe1\xef\xce\x43\xec\x73\x94\xbd\x71\xbe\x75\x0f\x4f\xd2\x82\x35\x09\x65\xd6\xb1\xeb\x49\x41\x47\x68\x85\x80\x96\xb6\x43\x4f\xa0\x45\x31\x22\x2b\x70\x21\x25\x49\x65\xef\x47\xf5\xfd\xa8\xaa\x4b\xb8\xd7\x46\xb6\xc8\x38\x24\xa8\xa6\x00\xdf\x23\xc9\xf0\xb5\xed\x23\xa7\x21\x6a\x0a\xc5\xec\xb5\xe0\x09\xb9\xe0\x56\x12\x4e\xf6\xe2\xe1\x0d\x9a\xab\xc9\x3c\x0d\xfd\xc8\x78\x9a\xf9\x4a\x62\x5d\x7c\x9b\xba\x44\xe8\x8d\xa6\xc0\x87\xed\xac\x60\x5c\xb8\x9f\x6b\xf3\xb4\xdf\x20\xcf\xed\xce\xaf\xdf\xd9\xdb\xe1\x1f\x80\x9d\x8b\x96\x65\x4e\x43\x57\xd8\x41\x43\x0c\x1f\x15\x6d\x30\x1a\x5e\xc2\xf5\xff\x3f\x25\x82\x74\x9a\x97\xb0\xb2\x9c\xfb\x99\x2a\x29\xe8\x26\x19\x40\x96\x9a\x2e\x32\x4a\xcc\xbd\xae\xee\x6e\x94\xca\xd6\xaf\x90\x62\x3f\x12\xa7\x4d\xa2\x1c\x07\xac\x9a\xd5\x1b\x0c\xc9\x20\xe9\xe1\x15\xa0\x55\xf2\x06\x21\xc4\xa6\xa1\x20\xa1\x4a\x93\x2f\x93\xd9\x46\xfb\x30\xaa\x46\x41\xd0\x88\x8e\x19\xa9\x1a\x72\x19\x59\x3e\x54\x24\x38\x1b\xd5\xe1\x3c\xd7\x6f\x94\xda\x03\x73\xb4\x8a\x3c\xa0\xcd\x92\x26\x21\x0b\x9c\x3d\x7d\x8f\xda\x53\xd8\xd3\x31\x54\x0a\x7a\xf2\x9d\x0e\x41\x3b\x9b\xab\x2b\xa7\x83\x9c\x1b\x6b\x4a\xfe\x71\x1d\x03\xa9\x45\x9a\x19\xa6\x89\xe6\x0e\xad\x09\x8c\x6b\x1a\x52\x49\xea\xf2\x1c\x6a\x8e\x68\x32\xcd\x9d\xff\x10\x92\x14\xc2\xea\x6e\x71\x02\xb2\x37\xc6\xb8\xed\x81\xfa\xb2\x83\xde\x85\xbf\x2a\xbc\x67\xbc\x04\xa2\xac\x64\x3d\x36\x72\xb2\x01\xda\x5d\x3e\x35\xe4\xa8\x0a\x84\xbe\x6e\xc1\x53\x88\x26\x9f\x23\x47\x0a\x3c\x8d\x27\x63\x22\xf3\x6a\xec\x72\xe9\x52\x8b\x2f\xb4\x38\xcd\xb0\x61\xba\x23\x3d\x0e\x54\xe9\x84\xf8\x9c\xd2\xb6\x39\xdc\xcb\x19\x75\x1a\xf8\x3f\x2b\xcd\x05\xf9\x93\x40\xe4\xa8\xec\xd2\xde\xb9\x53\xf8\x5f\x41\x8f\xbf\x81\x1d\xff\x79\x72\xdc\xb6\x68\x1b\x82\x6d\xb9\x55\xb0\x03\x9c\x80\x9e\x30\x2e\x29\x0e\x44\x99\xa7\xc6\x5b\x1f\x69\x70\xd3\x11\xbf\x7f\x9f\xca\x25\x1e\x30\xe3\x1c\x31\xfe\x51\x64\x0f\x8a\xfe\x84\xcd\x2c\xb6\x9f\xb0\x99\x74\x7d\x06\xdd\x58\xe6\xce\xd8\x00\xbb\xc5\xa9\xeb\x66\x5e\x16\xeb\x42\xe3\x25\x8c\x24\x9e\x4b\xcb\x53\xe7\x5e\xe8\xbd\xcc\x1e\x92\xd5\xe9\xe4\xb2\x97\x31\xbf\x8d\x77\xdd\x7b\x19\xe6\x2d\xa7\x92\xfc\xe2\x42\xd0\x6b\x43\xf0\x82\x26\x52\xbe\xf5\xa5\x64\x16\x03\x39\x2a\xb2\xb1\x3b\x24\x48\x49\xed\x8e\x42\xed\x75\x9f\xa0\x2b\x00\x18\xbe\x2c\xdc\x46\xae\xae\xae\x8e\x5d\x7a\xf2\xa0\x99\xba\x0a\xe0\xae\xbc\xca\x29\xfe\x4a\xdb\x30\x9c\xdd\x15\xa4\xc7\xbc\xb0\xb2\x79\xec\xc9\xed\x5a\x2e\xc2\xd3\x67\x48\xe3\xe4\xd7\xd9\x01\x7c\x6b\xac\x9f\x1b\xef\x62\xba\x16\x23\xa7\x2b\xb8\x7c\x4f\xe0\x2e\x51\x4d\x27\x57\xf0\xf0\xa5\x02\xf8\x3c\x9a\xe6\x30\xbf\x90\x25\x8f\xa6\xd8\xe4\x61\x40\x0a\x5e\xf8\x2f\x80\xf7\x3c\xde\x67\x53\x07\xaa\x1f\x7f\x06\x00\x00\xff\xff\x3b\xb1\x09\x16\x57\x0d\x00\x00")
-
-func typesStoryGraphqlBytes() ([]byte, error) {
-	return bindataRead(
-		_typesStoryGraphql,
-		"types/story.graphql",
-	)
-}
-
-func typesStoryGraphql() (*asset, error) {
-	bytes, err := typesStoryGraphqlBytes()
-	if err != nil {
-		return nil, err
-	}
-
-	info := bindataFileInfo{name: "types/story.graphql", size: 3415, mode: os.FileMode(420), modTime: time.Unix(1531585348, 0)}
-	a := &asset{bytes: bytes, info: info}
-	return a, nil
-}
-
-var _typesTagGraphql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xb4\x52\x41\x73\xd5\x3c\x0c\xbc\xe7\x57\x6c\xa7\x87\xef\x92\xef\x71\xef\xad\xc3\x70\x60\x60\xe0\xd0\xfe\x01\x3d\x47\x89\x3d\xd8\x52\xc6\x52\x52\x1e\x4c\xff\x3b\x63\xa7\x8f\x02\x67\x38\xd9\x71\xa4\xd5\xee\x6a\x6f\x71\x8f\x47\x5a\x90\x0c\x84\xc2\x24\x06\x9d\x41\x66\x1a\x12\x79\x92\x05\xe6\x5a\x13\x1b\x3c\x92\x23\xd2\xce\x98\xd8\x29\x65\x43\x12\x04\x2d\x45\x05\x4f\xc9\x23\x54\x18\x24\xea\x91\xeb\x69\xf0\xcb\xca\x1d\xf8\xfb\x00\xdc\xe2\x31\x32\x9c\x96\xff\x0c\x5f\x92\x4c\x03\xfa\x71\xd7\x0a\x3e\x24\x99\x6e\x86\x3f\x8a\x84\x0a\x0f\xe8\xc7\x1d\x1e\xbc\x26\x59\x6e\x86\xe7\x61\xf8\x57\x6c\x93\xac\x9b\x37\xe4\xf7\xfd\xf2\xb7\x39\xe7\xac\x4f\x3c\x61\xa7\xbc\xb1\x61\xd6\xda\x40\x4e\x1d\x95\x65\x2b\x57\xc8\x97\xb9\xf7\x02\xad\x0b\x49\xfa\x46\x9e\x54\x0e\xb1\x81\x3c\x44\x50\xce\x70\xae\xa5\x63\x24\xf9\x7f\x93\xb4\x73\x35\x46\xd0\xba\x6a\xed\xf5\x36\xc2\x99\x8a\x8d\x58\xaa\x6e\xab\x8d\x08\x5b\x76\x1b\x5b\x4f\x60\x1b\xc1\x1e\x4e\xa7\xd3\x00\x7c\xfe\x65\xca\xa1\xe6\x1e\x21\x52\xa5\xe0\x5c\x9b\x2a\x58\xd4\x2d\x4f\x87\x8f\x1e\x19\xfc\x95\x82\x63\xde\x72\xee\x3a\x9b\xf9\xed\xf9\x67\x53\x43\x7d\x7b\xfd\xb8\x42\x66\x0d\xaf\x42\xe4\xe2\xb1\xed\x69\xae\x5a\x40\x58\x33\x09\x3b\x5c\x41\x02\x36\xa7\x73\x4e\x16\x0b\x8b\x9f\xf0\x18\x93\xa1\xd0\x05\xba\x73\xcd\xb4\x1e\x7b\xa3\xdf\xdd\x19\x41\x32\x21\xcd\x30\x1d\x71\x56\x8f\x7d\x68\xb3\xb6\x47\xc3\x69\xb1\xab\x8a\x33\x63\x33\x9e\x1a\xc7\x8f\x2f\x94\x86\xab\xe1\xbc\xb3\xf8\xe1\xf4\x9a\xd5\xa1\xb5\xdd\xa8\x7a\xcf\x57\x7f\x6b\x7d\xef\x5a\xd9\xd1\xf4\xa9\x05\xe8\x45\x3f\x9d\x75\xe7\x11\xe7\xcd\x91\x1c\x93\xb2\xc1\x3c\xb5\x5d\x25\x46\xd9\xb2\xa7\x35\xf3\x6b\x34\x75\xe1\x1e\xbb\x1e\x1e\xe1\xa7\xfe\xe7\xf2\x26\x44\x5a\x9b\xf1\xb3\xd6\x42\x7e\x28\x3f\x9b\x66\xf6\x66\x7e\xb2\xbe\x91\xa6\xac\x31\x79\xe0\x86\x35\x3c\xff\x08\x00\x00\xff\xff\x1f\xbf\x7a\x64\xc0\x03\x00\x00")
-
-func typesTagGraphqlBytes() ([]byte, error) {
-	return bindataRead(
-		_typesTagGraphql,
-		"types/tag.graphql",
-	)
-}
-
-func typesTagGraphql() (*asset, error) {
-	bytes, err := typesTagGraphqlBytes()
-	if err != nil {
-		return nil, err
-	}
-
-	info := bindataFileInfo{name: "types/tag.graphql", size: 960, mode: os.FileMode(420), modTime: time.Unix(1530963938, 0)}
-	a := &asset{bytes: bytes, info: info}
-	return a, nil
-}
-
-var _typesUserGraphql = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\x4c\xcc\x41\x0a\xc2\x40\x0c\x85\xe1\x7d\x4e\xf1\x8a\xb7\xe8\x35\xd4\x95\xb8\x18\x6c\x6c\xdf\xa2\x99\x21\x89\x88\x88\x77\x97\x0e\x5d\x74\x19\xf2\xbd\xff\x84\xcb\xa2\xb8\x86\x3a\xf2\xd3\x14\x0c\x3c\xab\x83\x96\xea\xe5\x91\xb4\x19\x6f\xe6\x82\xd7\x26\x6a\x4b\x56\x0b\x14\x9b\x10\x9a\xdb\x37\xa4\xcf\x7a\xe0\x2b\x40\xef\xd1\xbb\xb7\xb2\xaa\x00\x9c\x46\x9c\xd3\x69\xf3\x20\x07\xd1\xd4\x57\x46\xb0\x9a\xe0\x70\xc4\x88\xdb\xae\xef\x83\xfc\xfe\x01\x00\x00\xff\xff\x74\x0a\x0a\x1c\xa0\x00\x00\x00")
-
-func typesUserGraphqlBytes() ([]byte, error) {
-	return bindataRead(
-		_typesUserGraphql,
-		"types/user.graphql",
-	)
-}
-
-func typesUserGraphql() (*asset, error) {
-	bytes, err := typesUserGraphqlBytes()
-	if err != nil {
-		return nil, err
-	}
-
-	info := bindataFileInfo{name: "types/user.graphql", size: 160, mode: os.FileMode(420), modTime: time.Unix(1525514069, 0)}
-	a := &asset{bytes: bytes, info: info}
-	return a, nil
-}
-
-// Asset loads and returns the asset for the given name.
-// It returns an error if the asset could not be found or
-// could not be loaded.
-func Asset(name string) ([]byte, error) {
-	cannonicalName := strings.Replace(name, "\\", "/", -1)
-	if f, ok := _bindata[cannonicalName]; ok {
-		a, err := f()
-		if err != nil {
-			return nil, fmt.Errorf("Asset %s can't read by error: %v", name, err)
-		}
-		return a.bytes, nil
-	}
-	return nil, fmt.Errorf("Asset %s not found", name)
-}
-
-// MustAsset is like Asset but panics when Asset would return an error.
-// It simplifies safe initialization of global variables.
-func MustAsset(name string) []byte {
-	a, err := Asset(name)
-	if err != nil {
-		panic("asset: Asset(" + name + "): " + err.Error())
-	}
-
-	return a
-}
-
-// AssetInfo loads and returns the asset info for the given name.
-// It returns an error if the asset could not be found or
-// could not be loaded.
-func AssetInfo(name string) (os.FileInfo, error) {
-	cannonicalName := strings.Replace(name, "\\", "/", -1)
-	if f, ok := _bindata[cannonicalName]; ok {
-		a, err := f()
-		if err != nil {
-			return nil, fmt.Errorf("AssetInfo %s can't read by error: %v", name, err)
-		}
-		return a.info, nil
-	}
-	return nil, fmt.Errorf("AssetInfo %s not found", name)
-}
-
-// AssetNames returns the names of the assets.
-func AssetNames() []string {
-	names := make([]string, 0, len(_bindata))
-	for name := range _bindata {
-		names = append(names, name)
-	}
-	return names
-}
-
-// _bindata is a table, holding each asset generator, mapped to its name.
-var _bindata = map[string]func() (*asset, error){
-	"root.graphql": rootGraphql,
-	"types/change.graphql": typesChangeGraphql,
-	"types/channel.graphql": typesChannelGraphql,
-	"types/chapter.graphql": typesChapterGraphql,
-	"types/character.graphql": typesCharacterGraphql,
-	"types/file.graphql": typesFileGraphql,
-	"types/log.graphql": typesLogGraphql,
-	"types/post.graphql": typesPostGraphql,
-	"types/session.graphql": typesSessionGraphql,
-	"types/story.graphql": typesStoryGraphql,
-	"types/tag.graphql": typesTagGraphql,
-	"types/user.graphql": typesUserGraphql,
-}
-
-// AssetDir returns the file names below a certain
-// directory embedded in the file by go-bindata.
-// For example if you run go-bindata on data/... and data contains the
-// following hierarchy:
-//     data/
-//       foo.txt
-//       img/
-//         a.png
-//         b.png
-// then AssetDir("data") would return []string{"foo.txt", "img"}
-// AssetDir("data/img") would return []string{"a.png", "b.png"}
-// AssetDir("foo.txt") and AssetDir("notexist") would return an error
-// AssetDir("") will return []string{"data"}.
-func AssetDir(name string) ([]string, error) {
-	node := _bintree
-	if len(name) != 0 {
-		cannonicalName := strings.Replace(name, "\\", "/", -1)
-		pathList := strings.Split(cannonicalName, "/")
-		for _, p := range pathList {
-			node = node.Children[p]
-			if node == nil {
-				return nil, fmt.Errorf("Asset %s not found", name)
-			}
-		}
-	}
-	if node.Func != nil {
-		return nil, fmt.Errorf("Asset %s not found", name)
-	}
-	rv := make([]string, 0, len(node.Children))
-	for childName := range node.Children {
-		rv = append(rv, childName)
-	}
-	return rv, nil
-}
-
-type bintree struct {
-	Func     func() (*asset, error)
-	Children map[string]*bintree
-}
-var _bintree = &bintree{nil, map[string]*bintree{
-	"root.graphql": &bintree{rootGraphql, map[string]*bintree{}},
-	"types": &bintree{nil, map[string]*bintree{
-		"change.graphql": &bintree{typesChangeGraphql, map[string]*bintree{}},
-		"channel.graphql": &bintree{typesChannelGraphql, map[string]*bintree{}},
-		"chapter.graphql": &bintree{typesChapterGraphql, map[string]*bintree{}},
-		"character.graphql": &bintree{typesCharacterGraphql, map[string]*bintree{}},
-		"file.graphql": &bintree{typesFileGraphql, map[string]*bintree{}},
-		"log.graphql": &bintree{typesLogGraphql, map[string]*bintree{}},
-		"post.graphql": &bintree{typesPostGraphql, map[string]*bintree{}},
-		"session.graphql": &bintree{typesSessionGraphql, map[string]*bintree{}},
-		"story.graphql": &bintree{typesStoryGraphql, map[string]*bintree{}},
-		"tag.graphql": &bintree{typesTagGraphql, map[string]*bintree{}},
-		"user.graphql": &bintree{typesUserGraphql, map[string]*bintree{}},
-	}},
-}}
-
-// RestoreAsset restores an asset under the given directory
-func RestoreAsset(dir, name string) error {
-	data, err := Asset(name)
-	if err != nil {
-		return err
-	}
-	info, err := AssetInfo(name)
-	if err != nil {
-		return err
-	}
-	err = os.MkdirAll(_filePath(dir, filepath.Dir(name)), os.FileMode(0755))
-	if err != nil {
-		return err
-	}
-	err = ioutil.WriteFile(_filePath(dir, name), data, info.Mode())
-	if err != nil {
-		return err
-	}
-	err = os.Chtimes(_filePath(dir, name), info.ModTime(), info.ModTime())
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-// RestoreAssets restores an asset under the given directory recursively
-func RestoreAssets(dir, name string) error {
-	children, err := AssetDir(name)
-	// File
-	if err != nil {
-		return RestoreAsset(dir, name)
-	}
-	// Dir
-	for _, child := range children {
-		err = RestoreAssets(dir, filepath.Join(name, child))
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-func _filePath(dir, name string) string {
-	cannonicalName := strings.Replace(name, "\\", "/", -1)
-	return filepath.Join(append([]string{dir}, strings.Split(cannonicalName, "/")...)...)
-}
-

graphql/schema/root.graphql

@@ -1,152 +0,0 @@
-# The Query type represents the read entry points into the API.
-type Query {
-  # Find character by either an ID or a nick.
-  character(id: String, nick: String): Character
-
-  # Find characters by either a list of ids, nicks or an author. Only one parameter at a time
-  characters(ids: [String!], nicks: [String!], author: String): [Character!]!
-  
-
-  # Find channel by name
-  channel(name: String!): Channel
-
-  # Find all channels. Specifying `logged: true` restricts the search to only logged.
-  channels(logged: Boolean): [Channel!]!  
-  
-
-  # Find log by ID
-  log(id: String): Log
-
-  # Find logs
-  logs(filter: LogsFilter): [LogHeader!]!
-
-
-  # Find post by ID.
-  post(id: String!): Post
-
-  # Find posts by IDs. It's meant to allow other parts of the UI to link to a cluster of posts, e.g. for a room description for the
-  # Mapp should it ever become a thing. This does not have a filter, since it's meant to be queried in the logs' response's selection set.
-  posts(ids: [String!]!): [Post!]!
-
-
-  # Find file by ID
-  file(id: String!): File
-
-  # Files get all available files. If includePublic is set, it will return public files as well
-  files(includePublic: Boolean, mimeTypes: [String!]): [File!]!
-
-
-  # Find story by ID
-  story(id: String!): Story
-
-  # Find stories
-  stories(filter: StoriesFilter): [Story!]!
-
-
-  # Find story chapter by ID
-  chapter(id: String!): Chapter
-
-
-  # Find all distinct tags used in stories
-  tags: [Tag!]!
-
-
-  # Find current session
-  session: Session!
-}
-
-# The Mutation type represents write entry points into the API.
-type Mutation {
-  # Add a new character
-  addCharacter(input: CharacterAddInput!): Character!
-
-  # Add nick to character
-  addCharacterNick(input: CharacterNickInput!): Character!
-  
-  # Remove nick from character
-  removeCharacterNick(input: CharacterNickInput!): Character!
-
-  # Edit character
-  editCharacter(input: CharacterEditInput!): Character!
-
-  # Remove a character
-  removeCharacter(id: String!): Character!
-
-
-  # Add a channel
-  addChannel(input: ChannelAddInput!): Channel!
-
-  # Edit a channel
-  editChannel(input: ChannelEditInput!): Channel!
-
-  # Remove a channel
-  removeChannel(name: String!): Channel!
-
-
-  # Add a new log
-  addLog(input: LogAddInput!): Log!
-
-  # Edit a log
-  editLog(input: LogEditInput!): Log!
-
-  # Remove a log
-  removeLog(id: String!): Log!
-
-
-  # Add a post
-  addPost(input: AddPostInput!): Post!
-
-  # Edit a post
-  editPost(input: EditPostInput!): Post!
-
-  # Move a post
-  movePost(input: MovePostInput!): Post!
-
-  # Remove a post
-  removePost(id: String!): Post!
-
-
-  # Edit a file
-  editFile(input: EditFileInput!): File!
-
-  # Remove a file
-  removeFile(id: String!): File!
-
-
-  # Add a story
-  addStory(input: StoryAddInput!): Story!
-  
-  # Add a story tag
-  addStoryTag(input: StoryTagAddInput!): Story!
-  
-  # Remove a story tag
-  removeStoryTag(input: StoryTagRemoveInput!): Story!
-  
-  # Edit a story
-  editStory(input: StoryEditInput!): Story!
-  
-  # Remove a story
-  removeStory(id: String!): Story!
-
-
-  # Add a chapter to a story
-  addChapter(input: ChapterAddInput!): Chapter!
-
-  # Edit a chapter
-  editChapter(input: ChapterEditInput!): Chapter!
-
-  # Remove a chapter
-  removeChapter(id: String!): Chapter!
-
-
-  # Log in
-  login(username: String!, password: String!): Session!
-  
-  # Log out
-  logout(): Session!
-}
-
-schema { 
-  query: Query
-  mutation: Mutation
-}

graphql/schema/schema.go

@@ -1,21 +0,0 @@
-package schema
-
-//go:generate go-bindata -ignore=\.go -pkg=schema -o=bindata.go ./...
-
-import "bytes"
-
-// String gets the schema
-func String() string {
-	buf := bytes.Buffer{}
-	for _, name := range AssetNames() {
-		b := MustAsset(name)
-		buf.Write(b)
-
-		// Add a newline if the file does not end in a newline.
-		if len(b) > 0 && b[len(b)-1] != '\n' {
-			buf.WriteByte('\n')
-		}
-	}
-
-	return buf.String()
-}

graphql/schema/types/change.graphql

@@ -1,4 +0,0 @@
-# A Change is a part of the history that can be used to keep clients up to date.
-type Change {
-  id: Int!
-}

graphql/schema/types/session.graphql

@@ -1,5 +0,0 @@
-# The session represents the current login state
-type Session {
-  # The user that is logged in, null if not logged in
-  user: User
-}

graphql/schema/types/user.graphql

@@ -1,8 +0,0 @@
-# The User type is for interacting with user options and settings
-type User {
-  # Their username
-  id: String!
-
-  # Their permission
-  permissions: [String!]!
-}

internal/auth/key.go

@@ -0,0 +1,109 @@
+package auth
+
+import (
+	"crypto/rand"
+	"encoding/binary"
+	"errors"
+	"strconv"
+
+	"git.aiterp.net/rpdata/api/internal/store"
+	"github.com/globalsign/mgo"
+)
+
+var keyCollection *mgo.Collection
+
+// A Key contains a JWT secret and the limitations of it. There are two types of
+// keys, single-user keys and wildcard keys. The former is used to authenticate
+// a single user (e.g. the logbot) through an API while the latter is only for
+// services that can be trusted to perform its own authentication (a frontend).
+type Key struct {
+	ID     string `bson:"_id"`
+	Name   string `bson:"name"`
+	User   string `bson:"user"`
+	Secret string `bson:"secret"`
+}
+
+// ValidForUser returns true if the key's user is the same as
+// the user, or it's a wildcard key.
+func (key *Key) ValidForUser(user string) bool {
+	return key.User == user || key.User == "*"
+}
+
+// FindKey finds a key by kid (key ID)
+func FindKey(kid string) (Key, error) {
+	key := Key{}
+	err := keyCollection.FindId(kid).One(&key)
+
+	return key, err
+}
+
+// NewKey generates a new key for the user and name. This
+// does not allow generating wildcard keys, they have to be
+// manually inserted into the DB.
+func NewKey(name, user string) (*Key, error) {
+	if user == "*" {
+		return nil, errors.New("auth: wildcard keys not allowed")
+	}
+
+	secret, err := makeKeySecret()
+	if err != nil {
+		return nil, err
+	}
+
+	key := &Key{
+		ID:     makeKeyID(),
+		Name:   name,
+		User:   user,
+		Secret: secret,
+	}
+
+	if err := keyCollection.Insert(key); err != nil {
+		return nil, err
+	}
+
+	return key, nil
+}
+
+func init() {
+	store.HandleInit(func(db *mgo.Database) {
+		keyCollection = db.C("auth.keys")
+
+		keyCollection.EnsureIndexKey("user")
+	})
+}
+
+// makeKeyID makes a random story ID that's 16 characters long
+func makeKeyID() string {
+	result := "K"
+	offset := 0
+	data := make([]byte, 32)
+
+	rand.Read(data)
+	for len(result) < 16 {
+		result += strconv.FormatUint(binary.LittleEndian.Uint64(data[offset:]), 36)
+		offset += 8
+
+		if offset >= 32 {
+			rand.Read(data)
+			offset = 0
+		}
+	}
+
+	return result[:16]
+}
+
+func makeKeySecret() (string, error) {
+	data := make([]byte, 64)
+	alphabet := "0123456789abcdefghjiklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSUTVWXYZ-_"
+
+	_, err := rand.Read(data)
+	if err != nil {
+		return "", err
+	}
+
+	for i := range data {
+		data[i] = alphabet[data[i]%64]
+	}
+
+	return string(data), nil
+}

internal/auth/permissions.go

@@ -1,16 +1,4 @@
-package session
-
-// DefaultPermissions gets the default permissions
-func DefaultPermissions() []string {
-	return []string{
-		"member",
-		"log.edit",
-		"log.reorder",
-		"post.edit",
-		"post.move",
-		"file.upload",
-	}
-}
+package auth
 
 // AllPermissions gets all permissions and their purpose
 func AllPermissions() map[string]string {
@@ -30,8 +18,10 @@ func AllPermissions() map[string]string {
 		"post.edit":        "Can edit posts",
 		"post.move":        "Can move posts",
 		"post.remove":      "Can remove posts",
+		"story.add":        "Can add non-owned stories",
 		"story.edit":       "Can edit non-owned stories",
 		"story.remove":     "Can remove non-owned stories",
+		"story.unlisted":   "Can view non-owned unlisted stories",
 		"file.upload":      "Can upload files",
 		"file.edit":        "Can edit non-owned files",
 		"file.remove":      "Can remove non-owned files",

internal/auth/token.go

@@ -0,0 +1,154 @@
+package auth
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"git.aiterp.net/rpdata/api/models"
+	"git.aiterp.net/rpdata/api/models/users"
+	jwt "github.com/dgrijalva/jwt-go"
+)
+
+var contextKey = &struct{ data string }{"Token Context Key"}
+
+// ErrNoKid is returned if the key id is missing from the jwt token header,
+var ErrNoKid = errors.New("Missing \"kid\" field in token")
+
+// ErrKeyNotFound is returned if the key wasn't found.
+var ErrKeyNotFound = errors.New("Key not found")
+
+// ErrInvalidClaims is returned by parseClaims if the claims cannot be parsed
+var ErrInvalidClaims = errors.New("Invalid claims in token")
+
+// ErrExpired is returned by parseClaims if the expiry date is in the past
+var ErrExpired = errors.New("Claims have already expired")
+
+// ErrWrongUser is returned by CheckToken if the key cannot represent this user
+var ErrWrongUser = errors.New("Key is not valid for this user")
+
+// ErrWrongPermissions is returned by CheckToken if the key cannot claim one or more of its permissions
+var ErrWrongPermissions = errors.New("User does not have these permissions")
+
+// ErrDeletedUser is returned by CheckToken if the key can represent this user, but the user doesn't exist.
+var ErrDeletedUser = errors.New("User was not found")
+
+// TokenFromContext gets the token from context.
+func TokenFromContext(ctx context.Context) *models.Token {
+	token, ok := ctx.Value(contextKey).(*models.Token)
+	if !ok {
+		return nil
+	}
+
+	return token
+}
+
+// RequestWithToken either returns the request, or the request with a new context that
+// has the token.
+func RequestWithToken(r *http.Request) *http.Request {
+	header := r.Header.Get("Authorization")
+	if header == "" {
+		return r
+	}
+
+	if !strings.HasPrefix(header, "Bearer ") {
+		return r
+	}
+
+	token, err := CheckToken(header[7:])
+	if err != nil {
+		return r
+	}
+
+	return r.WithContext(context.WithValue(r.Context(), contextKey, &token))
+}
+
+// CheckToken reads the token string and returns a token if everything is kosher.
+func CheckToken(tokenString string) (token models.Token, err error) {
+	var key Key
+
+	jwtToken, err := jwt.Parse(tokenString, func(jwtToken *jwt.Token) (interface{}, error) {
+		if _, ok := jwtToken.Method.(*jwt.SigningMethodHMAC); !ok {
+			return nil, fmt.Errorf("Unexpected signing method: %v", jwtToken.Header["alg"])
+		}
+
+		kid, ok := jwtToken.Header["kid"].(string)
+		if !ok {
+			return nil, ErrNoKid
+		}
+
+		key, err = FindKey(kid)
+		if err != nil || key.ID == "" {
+			return nil, ErrKeyNotFound
+		}
+
+		return []byte(key.Secret), nil
+	})
+	if err != nil {
+		return models.Token{}, err
+	}
+
+	userid, permissions, err := parseClaims(jwtToken.Claims)
+	if err != nil {
+		return models.Token{}, err
+	}
+
+	if !key.ValidForUser(userid) {
+		return models.Token{}, ErrWrongUser
+	}
+
+	user, err := users.Ensure(userid)
+	if err != nil {
+		return models.Token{}, ErrDeletedUser
+	}
+
+	acceptedPermissions := make([]string, 0, 8)
+	for _, permission := range permissions {
+		found := false
+
+		for _, userPermission := range user.Permissions {
+			if permission == userPermission {
+				found = true
+				break
+			}
+		}
+
+		if found {
+			acceptedPermissions = append(acceptedPermissions, permission)
+		}
+	}
+
+	return models.Token{UserID: user.ID, Permissions: acceptedPermissions}, nil
+}
+
+func parseClaims(jwtClaims jwt.Claims) (userid string, permissions []string, err error) {
+	mapClaims, ok := jwtClaims.(jwt.MapClaims)
+	if !ok {
+		return "", nil, ErrInvalidClaims
+	}
+
+	if !mapClaims.VerifyExpiresAt(time.Now().Unix(), true) {
+		return "", nil, ErrExpired
+	}
+
+	if userid, ok = mapClaims["user"].(string); !ok {
+		return "", nil, ErrInvalidClaims
+	}
+
+	if claimedPermissions, ok := mapClaims["permissions"].([]interface{}); ok {
+		for _, permission := range claimedPermissions {
+			if permission, ok := permission.(string); ok {
+				permissions = append(permissions, permission)
+			}
+		}
+	}
+
+	if len(permissions) == 0 {
+		return "", nil, ErrInvalidClaims
+	}
+
+	return
+}

internal/loader/channel.go

@@ -5,27 +5,30 @@ import (
 	"errors"
 	"strings"
 
-	"git.aiterp.net/rpdata/api/model/channel"
+	"git.aiterp.net/rpdata/api/models"
+	"git.aiterp.net/rpdata/api/models/channels"
 	"github.com/graph-gophers/dataloader"
 )
 
 // Channel gets a character by key
-func (loader *Loader) Channel(key, value string) (channel.Channel, error) {
+func (loader *Loader) Channel(key, value string) (models.Channel, error) {
 	if !strings.HasPrefix(key, "Channel.") {
 		key = "Channel." + key
 	}
 
 	if loader.loaders[key] == nil {
-		return channel.Channel{}, errors.New("unsupported key")
+		return models.Channel{}, errors.New("unsupported key")
 	}
 
+	loader.loadPrimed(key)
+
 	thunk := loader.loaders[key].Load(loader.ctx, dataloader.StringKey(value))
 	res, err := thunk()
 	if err != nil {
-		return channel.Channel{}, err
+		return models.Channel{}, err
 	}
 
-	channel, ok := res.(channel.Channel)
+	channel, ok := res.(models.Channel)
 	if !ok {
 		return channel, errors.New("incorrect type")
 	}
@@ -33,14 +36,23 @@ func (loader *Loader) Channel(key, value string) (channel.Channel, error) {
 	return channel, nil
 }
 
+// PrimeChannels primes channels for loading along with the first one.
+func (loader *Loader) PrimeChannels(key string, values ...string) {
+	if !strings.HasPrefix(key, "Channel.") {
+		key = "Channel." + key
+	}
+
+	loader.prime(key, values)
+}
+
 func channelNameBatch(ctx context.Context, keys dataloader.Keys) []*dataloader.Result {
 	var results []*dataloader.Result
 	names := keys.Keys()
 
-	channels, err := channel.ListNames(names...)
+	channels, err := channels.ListNames(names...)
 	if err != nil {
 		for range names {
-			results = append(results, &dataloader.Result{Data: channel.Channel{}, Error: err})
+			results = append(results, &dataloader.Result{Data: models.Channel{}, Error: err})
 		}
 
 		return results
@@ -58,7 +70,7 @@ func channelNameBatch(ctx context.Context, keys dataloader.Keys) []*dataloader.R
 		}
 
 		if !found {
-			results = append(results, &dataloader.Result{Data: channel.Channel{}, Error: err})
+			results = append(results, &dataloader.Result{Data: models.Channel{}, Error: err})
 		}
 	}
 

internal/loader/character.go

@@ -5,36 +5,39 @@ import (
 	"errors"
 	"strings"
 
-	"git.aiterp.net/rpdata/api/model/character"
+	"git.aiterp.net/rpdata/api/models"
+	"git.aiterp.net/rpdata/api/models/characters"
 	"github.com/graph-gophers/dataloader"
 )
 
 // Character gets a character by key
-func (loader *Loader) Character(key, value string) (character.Character, error) {
+func (loader *Loader) Character(key, value string) (models.Character, error) {
 	if !strings.HasPrefix(key, "Character.") {
 		key = "Character." + key
 	}
 
+	loader.loadPrimed(key)
+
 	if loader.loaders[key] == nil {
-		return character.Character{}, errors.New("unsupported key")
+		return models.Character{}, errors.New("unsupported key")
 	}
 
 	thunk := loader.loaders[key].Load(loader.ctx, dataloader.StringKey(value))
 	res, err := thunk()
 	if err != nil {
-		return character.Character{}, err
+		return models.Character{}, err
 	}
 
-	char, ok := res.(character.Character)
+	char, ok := res.(models.Character)
 	if !ok {
-		return character.Character{}, errors.New("incorrect type")
+		return models.Character{}, errors.New("incorrect type")
 	}
 
 	return char, nil
 }
 
 // Characters gets characters by key
-func (loader *Loader) Characters(key string, values ...string) ([]character.Character, error) {
+func (loader *Loader) Characters(key string, values ...string) ([]models.Character, error) {
 	if !strings.HasPrefix(key, "Character.") {
 		key = "Character." + key
 	}
@@ -43,6 +46,8 @@ func (loader *Loader) Characters(key string, values ...string) ([]character.Char
 		return nil, errors.New("unsupported key")
 	}
 
+	loader.loadPrimed(key)
+
 	thunk := loader.loaders[key].LoadMany(loader.ctx, dataloader.NewKeysFromStrings(values))
 	res, errs := thunk()
 	for _, err := range errs {
@@ -51,10 +56,10 @@ func (loader *Loader) Characters(key string, values ...string) ([]character.Char
 		}
 	}
 
-	chars := make([]character.Character, len(res))
+	chars := make([]models.Character, len(res))
 
 	for i := range res {
-		char, ok := res[i].(character.Character)
+		char, ok := res[i].(models.Character)
 		if !ok {
 			return nil, errors.New("incorrect type")
 		}
@@ -65,11 +70,22 @@ func (loader *Loader) Characters(key string, values ...string) ([]character.Char
 	return chars, nil
 }
 
+// PrimeCharacters adds a set of characters to be loaded if, and only if, characters
+// are going to be loaded. This will fill up the cache and speed up subsequent dataloader
+// runs.
+func (loader *Loader) PrimeCharacters(key string, values ...string) {
+	if !strings.HasPrefix(key, "Character.") {
+		key = "Character." + key
+	}
+
+	loader.prime(key, values)
+}
+
 func characterIDBatch(ctx context.Context, keys dataloader.Keys) []*dataloader.Result {
 	results := make([]*dataloader.Result, 0, len(keys))
 	ids := keys.Keys()
 
-	characters, err := character.ListIDs(ids...)
+	characters, err := characters.List(&characters.Filter{IDs: ids})
 	if err != nil {
 		for range ids {
 			results = append(results, &dataloader.Result{Error: err})
@@ -90,7 +106,7 @@ func characterIDBatch(ctx context.Context, keys dataloader.Keys) []*dataloader.R
 		}
 
 		if !found {
-			results = append(results, &dataloader.Result{Data: character.Character{}, Error: ErrNotFound})
+			results = append(results, &dataloader.Result{Data: models.Character{}, Error: ErrNotFound})
 		}
 	}
 
@@ -101,7 +117,7 @@ func characterNickBatch(ctx context.Context, keys dataloader.Keys) []*dataloader
 	var results []*dataloader.Result
 	nicks := keys.Keys()
 
-	characters, err := character.ListNicks(nicks...)
+	characters, err := characters.List(&characters.Filter{Nicks: nicks})
 	if err != nil {
 		for range nicks {
 			results = append(results, &dataloader.Result{Error: err})
@@ -122,7 +138,7 @@ func characterNickBatch(ctx context.Context, keys dataloader.Keys) []*dataloader
 		}
 
 		if !found {
-			results = append(results, &dataloader.Result{Data: character.Character{}, Error: err})
+			results = append(results, &dataloader.Result{Data: models.Character{}, Error: err})
 		}
 	}
 

internal/loader/loader.go

@@ -3,6 +3,7 @@ package loader
 import (
 	"context"
 	"errors"
+	"sync"
 	"time"
 
 	"github.com/graph-gophers/dataloader"
@@ -16,8 +17,11 @@ var ErrNotFound = errors.New("not found")
 // A Loader is a collection of data loaders and functions to act on them. It's supposed to be
 // request-scoped, and will thus keep things cached indefinitely.
 type Loader struct {
+	mutex   sync.Mutex
 	ctx     context.Context
 	loaders map[string]*dataloader.Loader
+
+	primedKeys map[string]map[string]bool
 }
 
 // New initializes the loader.
@@ -25,10 +29,11 @@ func New() *Loader {
 	return &Loader{
 		ctx: context.Background(),
 		loaders: map[string]*dataloader.Loader{
-			"Character.id":   dataloader.NewBatchedLoader(characterIDBatch, dataloader.WithWait(time.Millisecond)),
-			"Character.nick": dataloader.NewBatchedLoader(characterNickBatch, dataloader.WithWait(time.Millisecond)),
-			"Channel.name":   dataloader.NewBatchedLoader(channelNameBatch, dataloader.WithWait(time.Millisecond)),
+			"Character.id":   dataloader.NewBatchedLoader(characterIDBatch, dataloader.WithWait(time.Millisecond*2)),
+			"Character.nick": dataloader.NewBatchedLoader(characterNickBatch, dataloader.WithWait(time.Millisecond*2)),
+			"Channel.name":   dataloader.NewBatchedLoader(channelNameBatch, dataloader.WithWait(time.Millisecond*2)),
 		},
+		primedKeys: make(map[string]map[string]bool),
 	}
 }
 
@@ -47,3 +52,29 @@ func (loader *Loader) ToContext(ctx context.Context) context.Context {
 	loader.ctx = ctx
 	return context.WithValue(ctx, &contextKey, loader)
 }
+
+func (loader *Loader) prime(key string, values []string) {
+	loader.mutex.Lock()
+	if loader.primedKeys[key] == nil {
+		loader.primedKeys[key] = make(map[string]bool)
+	}
+
+	for _, value := range values {
+		loader.primedKeys[key][value] = true
+	}
+	loader.mutex.Unlock()
+}
+
+func (loader *Loader) loadPrimed(key string) {
+	loader.mutex.Lock()
+	if len(loader.primedKeys[key]) > 0 {
+		primedKeys := make([]string, 0, len(loader.primedKeys[key]))
+		for key := range loader.primedKeys[key] {
+			primedKeys = append(primedKeys, key)
+		}
+
+		loader.loaders[key].LoadMany(loader.ctx, dataloader.NewKeysFromStrings(primedKeys))
+		loader.primedKeys[key] = nil
+	}
+	loader.mutex.Unlock()
+}

internal/session/context.go

@@ -1,20 +0,0 @@
-package session
-
-import "context"
-
-type contextKeyType struct{ name string }
-
-func (ck *contextKeyType) String() string {
-	return ck.name
-}
-
-var contextKey = &contextKeyType{name: "session context key"}
-
-// FromContext gets a session fron the context.
-func FromContext(ctx context.Context) *Session {
-	return ctx.Value(contextKey).(*Session)
-}
-
-func contextWithSession(parent context.Context, session *Session) context.Context {
-	return context.WithValue(parent, contextKey, session)
-}

internal/session/session.go

@@ -1,182 +0,0 @@
-package session
-
-import (
-	"crypto/rand"
-	"encoding/hex"
-	"log"
-	"net/http"
-	"strings"
-	"sync"
-	"time"
-
-	"git.aiterp.net/aiterp/wikiauth"
-
-	"git.aiterp.net/rpdata/api/internal/config"
-	"git.aiterp.net/rpdata/api/internal/store"
-	"github.com/globalsign/mgo"
-	"github.com/globalsign/mgo/bson"
-)
-
-var sessionCollection *mgo.Collection
-
-// A Session represents a login session.
-type Session struct {
-	mutex sync.Mutex
-
-	ID     string    `bson:"_id"`
-	Time   time.Time `bson:"time"`
-	UserID string    `bson:"userId"`
-
-	user *User
-	w    http.ResponseWriter
-}
-
-// Load loads a session from a cookie, returning either `r` or a request
-// with the session context.
-func Load(w http.ResponseWriter, r *http.Request) *http.Request {
-	cookie, err := r.Cookie("aiterp_session")
-	if err != nil {
-		return r.WithContext(contextWithSession(r.Context(), &Session{w: w}))
-	}
-
-	id := cookie.Value
-
-	session := Session{}
-	err = sessionCollection.FindId(id).One(&session)
-	if err != nil || time.Since(session.Time) > time.Hour*168 {
-		return r.WithContext(contextWithSession(r.Context(), &Session{w: w}))
-	}
-
-	if session.ID != "" && time.Since(session.Time) > time.Second*30 {
-		session.Time = time.Now()
-		go sessionCollection.UpdateId(id, bson.M{"$set": bson.M{"time": session.Time}})
-	}
-
-	cookie.Expires = time.Now().Add(time.Hour * 168)
-	http.SetCookie(w, cookie)
-
-	session.w = w
-
-	return r.WithContext(contextWithSession(r.Context(), &session))
-}
-
-// Login logs a user in.
-func (session *Session) Login(username, password string) error {
-	auth := wikiauth.New(config.Global().Wiki.URL)
-
-	err := auth.Login(username, password)
-	if err != nil {
-		return err
-	}
-
-	// Allow bot passwords
-	username = strings.SplitN(username, "@", 2)[0]
-
-	data := make([]byte, 32)
-	_, err = rand.Read(data)
-	if err != nil {
-		return err
-	}
-
-	session.ID = hex.EncodeToString(data)
-	session.UserID = username
-	session.Time = time.Now()
-
-	err = sessionCollection.Insert(&session)
-	if err != nil {
-		return err
-	}
-
-	http.SetCookie(session.w, &http.Cookie{
-		Name:     "aiterp_session",
-		Value:    session.ID,
-		Expires:  time.Now().Add(time.Hour * 2160), // 90 days
-		HttpOnly: true,
-	})
-
-	user, err := FindUser(session.UserID)
-	if err == mgo.ErrNotFound {
-		user = User{ID: username, Nick: "", Permissions: DefaultPermissions()}
-
-		err := userCollection.Insert(user)
-		if err != nil {
-			return err
-		}
-	} else if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-// Logout logs out the session
-func (session *Session) Logout() {
-	http.SetCookie(session.w, &http.Cookie{
-		Name:     "aiterp_session",
-		Value:    "",
-		Expires:  time.Unix(0, 0),
-		HttpOnly: true,
-	})
-
-	session.mutex.Lock()
-	session.user = nil
-	session.UserID = ""
-	session.ID = ""
-	session.mutex.Unlock()
-
-	sessionCollection.RemoveId(session.ID)
-}
-
-// User gets the user information for the session.
-func (session *Session) User() *User {
-	session.mutex.Lock()
-	defer session.mutex.Unlock()
-
-	if session.user != nil {
-		return session.user
-	}
-
-	if session.UserID == "" {
-		return nil
-	}
-
-	user, err := FindUser(session.UserID)
-	if err != nil {
-		return nil
-	}
-
-	return &user
-}
-
-// NameOrPermitted is a shorthand for checking the username OR permissions, e.g. to check
-// if a logged in user can edit a certain post.
-func (session *Session) NameOrPermitted(userid string, permissions ...string) bool {
-	if session.UserID == userid {
-		return true
-	}
-
-	user := session.User()
-	if user == nil {
-		return false
-	}
-
-	return user.Permitted()
-}
-
-func init() {
-	store.HandleInit(func(db *mgo.Database) {
-		sessionCollection = db.C("core.sessions")
-
-		sessionCollection.EnsureIndexKey("nick")
-		sessionCollection.EnsureIndexKey("userId")
-
-		err := sessionCollection.EnsureIndex(mgo.Index{
-			Name:        "time",
-			Key:         []string{"time"},
-			ExpireAfter: time.Hour * 168,
-		})
-		if err != nil {
-			log.Fatalln(err)
-		}
-	})
-}

internal/task/task.go

@@ -0,0 +1,84 @@
+package task
+
+import (
+	"context"
+	"sync"
+	"time"
+)
+
+var globalCtx, globalCancel = context.WithCancel(context.Background())
+
+// A Task is a wrapper around a function that offers scheduling
+// and syncronization.
+type Task struct {
+	mutex        sync.Mutex
+	ctx          context.Context
+	ctxCancel    context.CancelFunc
+	waitDuration time.Duration
+	scheduled    bool
+	callback     func() error
+}
+
+// Context gets the task's context.
+func (task *Task) Context() context.Context {
+	return task.ctx
+}
+
+// Stop stops a task. This should not be done to stop a single run,
+// but as a way to cancel it forever.
+func (task *Task) Stop() {
+	task.ctxCancel()
+}
+
+// Schedule schedules a task for later execution.
+func (task *Task) Schedule() {
+	// Don't if the context is closed.
+	select {
+	case <-task.Context().Done():
+		return
+	default:
+	}
+
+	task.mutex.Lock()
+	if task.scheduled {
+		task.mutex.Unlock()
+		return
+	}
+	task.scheduled = true
+	task.mutex.Unlock()
+
+	go func() {
+		<-time.After(task.waitDuration)
+
+		// Mark as no longer scheduled
+		task.mutex.Lock()
+		task.scheduled = false
+		task.mutex.Unlock()
+
+		// Don't if the task is cancelled
+		select {
+		case <-task.Context().Done():
+			return
+		default:
+		}
+
+		task.callback()
+	}()
+}
+
+// New makes a new task with the callback.
+func New(waitDuration time.Duration, callback func() error) *Task {
+	ctx, ctxCancel := context.WithCancel(globalCtx)
+
+	return &Task{
+		callback:     callback,
+		ctx:          ctx,
+		ctxCancel:    ctxCancel,
+		waitDuration: waitDuration,
+	}
+}
+
+// StopAll stops all tasks.
+func StopAll() {
+	globalCancel()
+}

model/change/change.go

@@ -1,105 +0,0 @@
-package change
-
-import (
-	"log"
-	"sync"
-	"time"
-
-	"git.aiterp.net/rpdata/api/model/counter"
-
-	"git.aiterp.net/rpdata/api/internal/store"
-	"github.com/globalsign/mgo"
-)
-
-var collection *mgo.Collection
-
-// A Change represents a change in any other model
-type Change struct {
-	ID       int         `bson:"_id" json:"id"`
-	Time     time.Time   `bson:"time" json:"time"`
-	Model    string      `bson:"model" json:"model"`
-	Op       string      `bson:"op" json:"op"`
-	Author   string      `bson:"author,omitempty" json:"author,omitempty"`
-	ObjectID string      `bson:"objectId,omitempty" json:"objectId,omitempty"`
-	Data     interface{} `bson:"data,omitempty" json:"data,omitempty"`
-}
-
-// PublicModels lists which models can be listed in bulk by anyone.
-var PublicModels = []string{
-	"Character",
-	"Log",
-	"Post",
-}
-
-var submitMutex sync.Mutex
-
-// Submit submits a change to the history.
-func Submit(model, op, author, objectID string, data interface{}) (Change, error) {
-	submitMutex.Lock()
-	defer submitMutex.Unlock()
-
-	index, err := counter.Next("auto_increment", "Change")
-	if err != nil {
-		return Change{}, err
-	}
-
-	change := Change{
-		ID:       index,
-		Time:     time.Now(),
-		Model:    model,
-		Op:       op,
-		Author:   author,
-		ObjectID: objectID,
-		Data:     data,
-	}
-
-	Timeline.push(change)
-
-	err = collection.Insert(&change)
-	if err != nil {
-		return Change{}, err
-	}
-
-	return change, err
-}
-
-// FindID gets a change by ID
-func FindID(id int) (Change, error) {
-	change := Change{}
-	err := collection.FindId(id).One(&change)
-	if err != nil {
-		return Change{}, err
-	}
-
-	return change, nil
-}
-
-// List gets all changes in ascending order
-func List() ([]Change, error) {
-	changes := make([]Change, 0, 64)
-	err := collection.Find(nil).Sort("_id").All(&changes)
-	if err != nil {
-		return nil, err
-	}
-
-	return changes, nil
-}
-
-func init() {
-	store.HandleInit(func(db *mgo.Database) {
-		collection = db.C("common.history")
-
-		collection.EnsureIndexKey("model")
-		collection.EnsureIndexKey("author")
-		collection.EnsureIndexKey("objectId")
-
-		err := collection.EnsureIndex(mgo.Index{
-			Name:        "expiry",
-			Key:         []string{"time"},
-			ExpireAfter: time.Hour * 336,
-		})
-		if err != nil {
-			log.Fatalln(err)
-		}
-	})
-}

model/change/timeline.go

@@ -1,118 +0,0 @@
-package change
-
-import (
-	"context"
-	"errors"
-	"sync"
-
-	"github.com/globalsign/mgo"
-)
-
-// ErrInvalidIndex is returned when a timeline subscriber tries to get a value
-// with a negative id
-var ErrInvalidIndex = errors.New("change.timeline: Invalid ID")
-
-// ErrWaitRequired is returned when a timeline subscriber requests an entry that
-// has not yet been pushed
-var ErrWaitRequired = errors.New("change.timeline: Waiting required")
-
-// ErrExpired is returned when a timeline subscriber requests a change that happened
-// too long ago for it to be in the database.
-var ErrExpired = errors.New("change.timeline: Change has expired")
-
-type timeline struct {
-	mutex      sync.Mutex
-	firstIndex int64
-	currentID  int64
-	cache      []Change
-	notifyCh   chan struct{}
-}
-
-func (timeline *timeline) Get(ctx context.Context, id int64) (Change, error) {
-	change, err := timeline.get(id, false)
-	if err == ErrWaitRequired {
-		if err := timeline.wait(ctx); err != nil {
-			return Change{}, err
-		}
-
-		return timeline.get(id, true)
-	} else if err == mgo.ErrNotFound {
-		return Change{}, ErrExpired
-	}
-
-	return change, nil
-}
-
-func (timeline *timeline) push(change Change) {
-	timeline.mutex.Lock()
-	timeline.cache = append(timeline.cache, change)
-	if len(timeline.cache) > 128 {
-		copy(timeline.cache, timeline.cache[32:])
-		timeline.cache = timeline.cache[:len(timeline.cache)-32]
-	}
-
-	// Only update the currentID if this is more recent than the existing ones
-	if int64(change.ID) > timeline.currentID {
-		timeline.currentID = int64(change.ID)
-	}
-
-	if timeline.notifyCh != nil {
-		close(timeline.notifyCh)
-		timeline.notifyCh = nil
-	}
-	timeline.mutex.Unlock()
-}
-
-func (timeline *timeline) get(id int64, hasWaited bool) (Change, error) {
-	if id < 0 {
-		return Change{}, ErrInvalidIndex
-	}
-
-	timeline.mutex.Lock()
-	if !hasWaited && id > timeline.currentID {
-		timeline.mutex.Unlock()
-		return Change{}, ErrWaitRequired
-	}
-
-	for _, change := range timeline.cache {
-		if change.ID == int(id) {
-			timeline.mutex.Unlock()
-			return change, nil
-		}
-	}
-	timeline.mutex.Unlock()
-
-	return FindID(int(id))
-}
-
-func (timeline *timeline) wait(ctx context.Context) error {
-	timeline.mutex.Lock()
-	if timeline.notifyCh == nil {
-		timeline.notifyCh = make(chan struct{})
-	}
-
-	ch := timeline.notifyCh
-	timeline.mutex.Unlock()
-
-	select {
-	case <-ctx.Done():
-		return ctx.Err()
-	case <-ch:
-		return nil
-	}
-}
-
-// Timeline has operations for subscribing to changes in real time
-var Timeline = &timeline{}
-
-// InitializeTimeline fills in the timeline with existing entries
-func InitializeTimeline() {
-	changes, err := List()
-	if err != nil {
-		return
-	}
-
-	for _, change := range changes {
-		Timeline.push(change)
-	}
-}

model/channel/channel.go

@@ -1,143 +0,0 @@
-package channel
-
-import (
-	"errors"
-	"strings"
-
-	"git.aiterp.net/rpdata/api/internal/store"
-	"github.com/globalsign/mgo"
-	"github.com/globalsign/mgo/bson"
-)
-
-var collection *mgo.Collection
-
-// ErrInvalidName is an error for an invalid channel name
-var ErrInvalidName = errors.New("Invalid channel name")
-
-// A Channel represents information abount an IRC RP channel, and whether it should be logged
-type Channel struct {
-	Name     string `bson:"_id"`
-	Logged   bool   `bson:"logged"`
-	Hub      bool   `bson:"hub"`
-	Event    string `bson:"event,omitempty"`
-	Location string `bson:"location,omitempty"`
-}
-
-// Edit edits the channel
-func (channel *Channel) Edit(logged, hub *bool, event, location *string) error {
-	changes := bson.M{}
-	changed := *channel
-
-	if logged != nil && channel.Logged != *logged {
-		changes["logged"] = *logged
-		changed.Logged = *logged
-	}
-	if hub != nil && channel.Hub != *hub {
-		changes["hub"] = *hub
-		changed.Hub = *hub
-	}
-	if event != nil && channel.Event != *event {
-		changes["event"] = *event
-		changed.Event = *event
-	}
-	if location != nil && channel.Event != *location {
-		changes["location"] = *location
-		changed.Location = *location
-	}
-
-	if len(changes) == 0 {
-		return nil
-	}
-
-	err := collection.UpdateId(channel.Name, bson.M{"$set": changes})
-	if err != nil {
-		return err
-	}
-
-	*channel = changed
-
-	return nil
-}
-
-// Remove removes the channel information from the database.
-func (channel *Channel) Remove() error {
-	return collection.RemoveId(channel.Name)
-}
-
-// Ensure ensures a channel's existence. It does not change `logged` if there is
-// an existing channel.
-func Ensure(name string, logged bool) (Channel, error) {
-	channel, err := FindName(name)
-	if err == mgo.ErrNotFound {
-		return New(name, logged, false, "", "")
-	} else if err != nil {
-		return Channel{}, err
-	}
-
-	return channel, nil
-}
-
-// New creates a new channel
-func New(name string, logged, hub bool, event, location string) (Channel, error) {
-	if len(name) < 3 && !strings.HasPrefix(name, "#") {
-		return Channel{}, ErrInvalidName
-	}
-
-	channel := Channel{
-		Name:     name,
-		Logged:   logged,
-		Hub:      hub,
-		Event:    event,
-		Location: location,
-	}
-
-	err := collection.Insert(channel)
-	if err != nil {
-		return Channel{}, err
-	}
-
-	return channel, nil
-}
-
-// FindName finds a channel by its id (its name).
-func FindName(name string) (Channel, error) {
-	channel := Channel{}
-	err := collection.FindId(name).One(&channel)
-
-	return channel, err
-}
-
-// List finds channels, if logged is true it will be limited to logged
-// channels
-func List(logged bool) ([]Channel, error) {
-	query := bson.M{}
-	if logged {
-		query["logged"] = true
-	}
-
-	channels := make([]Channel, 0, 32)
-	err := collection.Find(query).All(&channels)
-
-	return channels, err
-}
-
-// ListNames finds channels by the names provided
-func ListNames(names ...string) ([]Channel, error) {
-	query := bson.M{"_id": bson.M{"$in": names}}
-
-	channels := make([]Channel, 0, 32)
-	err := collection.Find(query).All(&channels)
-
-	return channels, err
-}
-
-func init() {
-	store.HandleInit(func(db *mgo.Database) {
-		collection = db.C("common.channels")
-
-		collection.EnsureIndexKey("logged")
-		collection.EnsureIndexKey("hub")
-		collection.EnsureIndexKey("event")
-		collection.EnsureIndexKey("location")
-	})
-}

model/character/character.go

@@ -1,231 +0,0 @@
-package character
-
-import (
-	"errors"
-	"log"
-	"strconv"
-	"strings"
-
-	"git.aiterp.net/rpdata/api/internal/store"
-	"git.aiterp.net/rpdata/api/model/counter"
-	"github.com/globalsign/mgo"
-	"github.com/globalsign/mgo/bson"
-)
-
-var collection *mgo.Collection
-
-// Character is a common data model representing an RP character or NPC.
-type Character struct {
-	ID          string   `json:"id" bson:"_id"`
-	Nicks       []string `json:"nicks" bson:"nicks"`
-	Name        string   `json:"name" bson:"name"`
-	ShortName   string   `json:"shortName" bson:"shortName"`
-	Author      string   `json:"author" bson:"author"`
-	Description string   `json:"description" bson:"description"`
-}
-
-// HasNick returns true if the character has that nick
-func (character *Character) HasNick(nick string) bool {
-	for i := range character.Nicks {
-		if strings.EqualFold(character.Nicks[i], nick) {
-			return true
-		}
-	}
-
-	return false
-}
-
-// AddNick adds a nick to the character. It will return an error
-// if the nick already exists.
-func (character *Character) AddNick(nick string) error {
-	for i := range character.Nicks {
-		if strings.EqualFold(character.Nicks[i], nick) {
-			return errors.New("Nick already exists")
-		}
-	}
-
-	err := collection.UpdateId(character.ID, bson.M{"$push": bson.M{"nicks": nick}})
-	if err != nil {
-		return err
-	}
-
-	character.Nicks = append(character.Nicks, nick)
-
-	return nil
-}
-
-// RemoveNick removes the nick from the character. It will raise
-// an error if the nick does not exist; even if that kind of is
-// the end goal.
-func (character *Character) RemoveNick(nick string) error {
-	index := -1
-	for i := range character.Nicks {
-		if strings.EqualFold(character.Nicks[i], nick) {
-			index = i
-			break
-		}
-	}
-	if index == -1 {
-		return errors.New("Nick does not exist")
-	}
-
-	err := collection.UpdateId(character.ID, bson.M{"$pull": bson.M{"nicks": nick}})
-	if err != nil {
-		return err
-	}
-
-	character.Nicks = append(character.Nicks[:index], character.Nicks[index+1:]...)
-
-	return nil
-}
-
-// Edit sets the fields of metadata. Only non-empty and different fields will be set in the
-// database, preventing out of order edits to two fields from conflicting
-func (character *Character) Edit(name, shortName, description string) error {
-	changes := bson.M{}
-	if len(name) > 0 && name != character.Name {
-		changes["name"] = name
-	}
-	if len(shortName) > 0 && shortName != character.ShortName {
-		changes["shortName"] = shortName
-	}
-	if len(description) > 0 && description != character.Description {
-		changes["description"] = description
-	}
-
-	err := collection.UpdateId(character.ID, changes)
-	if err != nil {
-		return err
-	}
-
-	if changes["name"] != nil {
-		character.Name = name
-	}
-	if changes["shortName"] != nil {
-		character.ShortName = shortName
-	}
-	if changes["description"] != nil {
-		character.Description = description
-	}
-
-	return nil
-}
-
-// Remove removes the character from the database. The reason this is an instance method
-// is that it should only be done after an authorization check.
-func (character *Character) Remove() error {
-	return collection.RemoveId(character.ID)
-}
-
-// FindID finds Character by ID
-func FindID(id string) (Character, error) {
-	return find(bson.M{"_id": id})
-}
-
-// FindNick finds Character by nick
-func FindNick(nick string) (Character, error) {
-	return find(bson.M{"nicks": nick})
-}
-
-// FindName finds Character by either full name or
-// short name.
-func FindName(name string) (Character, error) {
-	return find(bson.M{"$or": []bson.M{bson.M{"name": name}, bson.M{"shortName": name}}})
-}
-
-// List lists all characters
-func List() ([]Character, error) {
-	return list(bson.M{})
-}
-
-// ListAuthor lists all characters by author
-func ListAuthor(author string) ([]Character, error) {
-	return list(bson.M{"author": author})
-}
-
-// ListNicks lists all characters with either of these nicks. This was made with
-// the logbot in mind, to batch an order for characters.
-func ListNicks(nicks ...string) ([]Character, error) {
-	return list(bson.M{"nicks": bson.M{"$in": nicks}})
-}
-
-// ListIDs lists all characters with either of these IDs.
-func ListIDs(ids ...string) ([]Character, error) {
-	return list(bson.M{"_id": bson.M{"$in": ids}})
-}
-
-// New creates a Character and pushes it to the database. It does some validation
-// on nick, name, shortName and author. Leave the shortname blank to have it be the
-// first name.
-func New(nick, name, shortName, author, description string) (Character, error) {
-	if len(nick) < 1 || len(name) < 1 || len(author) < 1 {
-		return Character{}, errors.New("Nick, name, or author name too short or empty")
-	}
-	if shortName == "" {
-		shortName = strings.SplitN(name, " ", 2)[0]
-	}
-
-	char, err := FindNick(nick)
-	if err == nil && char.ID != "" {
-		return Character{}, errors.New("Nick is occupied")
-	}
-
-	nextID, err := counter.Next("auto_increment", "Character")
-	if err != nil {
-		return Character{}, err
-	}
-
-	character := Character{
-		ID:          "C" + strconv.Itoa(nextID),
-		Nicks:       []string{nick},
-		Name:        name,
-		ShortName:   shortName,
-		Author:      author,
-		Description: description,
-	}
-
-	err = collection.Insert(character)
-	if err != nil {
-		return Character{}, err
-	}
-
-	return character, nil
-}
-
-func find(query interface{}) (Character, error) {
-	character := Character{}
-	err := collection.Find(query).One(&character)
-	if err != nil {
-		return Character{}, err
-	}
-
-	return character, nil
-}
-
-func list(query interface{}) ([]Character, error) {
-	characters := make([]Character, 0, 64)
-	err := collection.Find(query).All(&characters)
-	if err != nil {
-		return nil, err
-	}
-
-	return characters, nil
-}
-
-func init() {
-	store.HandleInit(func(db *mgo.Database) {
-		collection = db.C("common.characters")
-
-		collection.EnsureIndexKey("name")
-		collection.EnsureIndexKey("shortName")
-		collection.EnsureIndexKey("author")
-		err := collection.EnsureIndex(mgo.Index{
-			Key:      []string{"nicks"},
-			Unique:   true,
-			DropDups: true,
-		})
-		if err != nil {
-			log.Fatalln("init common.characters:", err)
-		}
-	})
-}

model/file/file.go

@@ -1,252 +0,0 @@
-package file
-
-import (
-	"context"
-	"crypto/rand"
-	"encoding/binary"
-	"errors"
-	"io"
-	"strconv"
-	"time"
-
-	"git.aiterp.net/rpdata/api/internal/store"
-	"github.com/globalsign/mgo"
-	"github.com/globalsign/mgo/bson"
-)
-
-var fileCollection *mgo.Collection
-
-// A File is a record of a file stored in the Space.
-type File struct {
-	ID       string    `bson:"_id" json:"id"`
-	Time     time.Time `bson:"time" json:"time"`
-	Kind     string    `bson:"kind" json:"kind"`
-	Public   bool      `bson:"public" json:"public"`
-	Name     string    `bson:"name" json:"name"`
-	MimeType string    `bson:"mimeType" json:"mimeType"`
-	Size     int64     `bson:"size" json:"size"`
-	Author   string    `bson:"author" json:"author"`
-	URL      string    `bson:"url,omitempty" json:"url,omitempty"`
-}
-
-// Edit edits the file, changing up to both the two mutable properties
-func (file *File) Edit(name *string, public *bool) error {
-	changes := bson.M{}
-	changedFile := *file
-
-	if name != nil && *name != file.Name {
-		changes["name"] = *name
-		changedFile.Name = *name
-	}
-	if public != nil && *public != file.Public {
-		changes["public"] = *public
-		changedFile.Public = *public
-	}
-
-	if len(changes) == 0 {
-		return nil
-	}
-
-	err := fileCollection.UpdateId(file.ID, bson.M{"$set": changes})
-	if err != nil {
-		return err
-	}
-
-	*file = changedFile
-
-	return nil
-}
-
-// Delete removes the file information from the database, and deletes the file.
-func (file *File) Delete() error {
-	err := fileCollection.RemoveId(file.ID)
-	if err != nil {
-		return err
-	}
-
-	if file.Kind == "upload" {
-		err = store.RemoveFile("files", file.ID)
-		if err != nil {
-			return err
-		}
-	}
-
-	file.URL = ""
-
-	return nil
-}
-
-// Insert manually inserts file information into the database. This should never, ever be API accessible
-func Insert(name, kind, mimeType, author string, time time.Time, size int64, url string) (File, error) {
-	file := File{
-		ID:       makeFileID(),
-		Kind:     kind,
-		Time:     time,
-		Public:   false,
-		Author:   author,
-		Name:     name,
-		MimeType: mimeType,
-		Size:     size,
-		URL:      url,
-	}
-
-	err := fileCollection.Insert(file)
-	if err != nil {
-		return File{}, err
-	}
-
-	return file, nil
-}
-
-// Upload adds a file to the space.
-func Upload(ctx context.Context, name, mimeType, author string, size int64, input io.Reader) (File, error) {
-	if !allowdMimeTypes[mimeType] {
-		return File{}, errors.New("File type not allowed:" + mimeType)
-	}
-
-	if name == "" {
-		date := time.Now().UTC().Format("Jan 02 2006 15:04:05 MST")
-		name = "Unnamed file (" + date + ")"
-	}
-
-	if mimeType == "" {
-		mimeType = "binary/octet-stream"
-	}
-
-	id := makeFileID()
-
-	path, err := store.UploadFile(ctx, "files", id, mimeType, input, size)
-	if err != nil {
-		return File{}, err
-	}
-
-	file := File{
-		ID:       id,
-		Kind:     "upload",
-		Time:     time.Now(),
-		Public:   false,
-		Author:   author,
-		Name:     name,
-		MimeType: mimeType,
-		Size:     size,
-		URL:      store.URLFromPath(path),
-	}
-
-	err = fileCollection.Insert(file)
-	if err != nil {
-		return File{}, err
-	}
-
-	return file, nil
-}
-
-// FindID finds a file by ID
-func FindID(id string) (File, error) {
-	file := File{}
-
-	err := fileCollection.FindId(id).One(&file)
-	if err != nil {
-		return File{}, err
-	}
-
-	return file, nil
-}
-
-// FindName finds a file by kind, name and author
-func FindName(kind string, name string, author string) (File, error) {
-	query := bson.M{"kind": kind, "name": name, "author": author}
-	file := File{}
-
-	err := fileCollection.Find(query).One(&file)
-	if err != nil {
-		return File{}, err
-	}
-
-	return file, nil
-}
-
-// List lists files according to the standard lookup. By default it's just the author's own files,
-// but if `public` is true it will alos include files made public by other authors. If `mimeTypes` contains
-// any, it will limit the results to that. If `author` is empty, it will only list public files
-func List(author string, public bool, mimeTypes []string) ([]File, error) {
-	query := bson.M{}
-
-	if author != "" {
-		if public {
-			query["$or"] = []bson.M{
-				bson.M{"author": author},
-				bson.M{"public": true},
-			}
-		} else {
-			query["author"] = author
-		}
-	} else {
-		if !public {
-			return nil, errors.New("No author specified, and public is unset")
-		}
-
-		query["public"] = true
-	}
-
-	if len(mimeTypes) > 0 {
-		query["mimeTypes"] = bson.M{"$in": mimeTypes}
-	}
-
-	return listFiles(query)
-}
-
-func listFiles(query interface{}) ([]File, error) {
-	list := make([]File, 0, 32)
-
-	err := fileCollection.Find(query).Sort("-time").All(&list)
-	if err != nil {
-		return nil, err
-	}
-
-	return list, nil
-}
-
-// makeFileID makes a random file ID that's 32 characters long
-func makeFileID() string {
-	result := "F" + strconv.FormatInt(time.Now().UnixNano(), 36)
-	offset := 0
-	data := make([]byte, 32)
-
-	rand.Read(data)
-	for len(result) < 32 {
-		result += strconv.FormatUint(binary.LittleEndian.Uint64(data[offset:]), 36)
-		offset += 8
-
-		if offset >= 32 {
-			rand.Read(data)
-			offset = 0
-		}
-	}
-
-	return result[:32]
-}
-
-func init() {
-	store.HandleInit(func(db *mgo.Database) {
-		fileCollection = db.C("file.headers")
-
-		fileCollection.EnsureIndexKey("author")
-		fileCollection.EnsureIndexKey("public")
-		fileCollection.EnsureIndexKey("kind", "name", "author")
-		fileCollection.EnsureIndexKey("author", "public")
-		fileCollection.EnsureIndexKey("kind")
-	})
-}
-
-var allowdMimeTypes = map[string]bool{
-	"":                    false,
-	"image/jpeg":          true,
-	"image/png":           true,
-	"image/gif":           true,
-	"text/plain":          true,
-	"application/json":    true,
-	"application/pdf":     false,
-	"binary/octet-stream": false,
-	"video/mp4":           false,
-	"audio/mp3":           false,
-}

model/log/log.go

@@ -1,388 +0,0 @@
-package log
-
-import (
-	"errors"
-	"fmt"
-	"log"
-	"sort"
-	"strconv"
-	"strings"
-	"sync"
-	"time"
-
-	"git.aiterp.net/rpdata/api/internal/store"
-	"git.aiterp.net/rpdata/api/model/channel"
-	"git.aiterp.net/rpdata/api/model/character"
-	"git.aiterp.net/rpdata/api/model/counter"
-
-	"github.com/globalsign/mgo/bson"
-
-	"github.com/globalsign/mgo"
-)
-
-var postMutex sync.RWMutex
-
-var characterUpdateMutex sync.Mutex
-
-var logsCollection *mgo.Collection
-
-// Log is the header/session for a log file.
-type Log struct {
-	ID           string    `bson:"_id"`
-	ShortID      string    `bson:"shortId"`
-	Date         time.Time `bson:"date"`
-	Channel      string    `bson:"channel"`
-	Title        string    `bson:"title,omitempty"`
-	Event        string    `bson:"event,omitempty"`
-	Description  string    `bson:"description,omitempty"`
-	Open         bool      `bson:"open"`
-	CharacterIDs []string  `bson:"characterIds"`
-}
-
-// New creates a new Log
-func New(date time.Time, channelName, title, event, description string, open bool) (Log, error) {
-	nextID, err := counter.Next("auto_increment", "Log")
-	if err != nil {
-		return Log{}, err
-	}
-
-	_, err = channel.Ensure(channelName, open)
-	if err != nil {
-		return Log{}, err
-	}
-
-	log := Log{
-		ID:           MakeLogID(date, channelName),
-		ShortID:      "L" + strconv.Itoa(nextID),
-		Date:         date,
-		Channel:      channelName,
-		Title:        title,
-		Event:        event,
-		Description:  description,
-		Open:         open,
-		CharacterIDs: nil,
-	}
-
-	err = logsCollection.Insert(log)
-	if err != nil {
-		return Log{}, err
-	}
-
-	return log, nil
-}
-
-// FindID finds a log either by it's ID or short ID.
-func FindID(id string) (Log, error) {
-	return findLog(bson.M{
-		"$or": []bson.M{
-			bson.M{"_id": id},
-			bson.M{"shortId": id},
-		},
-	})
-}
-
-// List lists all logs
-func List(limit int) ([]Log, error) {
-	return listLog(bson.M{}, limit)
-}
-
-// ListSearch lists the logs matching the parameters. Empty/zero values means the parameter is ingored when
-// building the query. This is the old aitelogs2 way, but with the addition of a text search.
-//
-// If a text search is specified, it will make two trips to the database.
-func ListSearch(textSearch string, channels []string, characterIds []string, events []string, open bool, limit int) ([]Log, error) {
-	postMutex.RLock()
-	defer postMutex.RUnlock()
-
-	query := bson.M{}
-
-	// Run a text search
-	if textSearch != "" {
-		searchResults := make([]string, 0, 32)
-
-		err := postCollection.Find(bson.M{"$text": bson.M{"$search": textSearch}}).Distinct("logId", &searchResults)
-		if err != nil {
-			return nil, err
-		}
-
-		// Posts always use shortId to refer to the log
-		query["shortId"] = bson.M{"$in": searchResults}
-	}
-
-	// Find logs including any of the specified events and channels
-	if len(channels) > 0 {
-		query["channel"] = bson.M{"$in": channels}
-	}
-	if len(events) > 0 {
-		query["events"] = bson.M{"$in": channels}
-	}
-
-	// Find logs including all of the specified character IDs.
-	if len(characterIds) > 0 {
-		query["characterIds"] = bson.M{"$all": characterIds}
-	}
-
-	// Limit to only open logs
-	if open {
-		query["open"] = true
-	}
-
-	return listLog(query, limit)
-}
-
-// Edit sets the metadata
-func (log *Log) Edit(title *string, event *string, description *string, open *bool) error {
-	changes := bson.M{}
-
-	if title != nil && *title != log.Title {
-		changes["title"] = *title
-	}
-	if event != nil && *event != log.Event {
-		changes["event"] = *event
-	}
-	if description != nil && *description != log.Description {
-		changes["description"] = *description
-	}
-	if open != nil && *open != log.Open {
-		changes["open"] = *open
-	}
-
-	if len(changes) == 0 {
-		return nil
-	}
-
-	err := logsCollection.UpdateId(log.ID, bson.M{"$set": changes})
-	if err != nil {
-		return err
-	}
-
-	if title != nil {
-		log.Title = *title
-	}
-	if event != nil {
-		log.Event = *event
-	}
-	if description != nil {
-		log.Description = *description
-	}
-	if open != nil {
-		log.Open = *open
-	}
-
-	return nil
-}
-
-// Posts gets all the posts under the log. If no kinds are specified, it
-// will get all posts
-func (log *Log) Posts(kinds ...string) ([]Post, error) {
-	postMutex.RLock()
-	defer postMutex.RUnlock()
-
-	query := bson.M{
-		"$or": []bson.M{
-			bson.M{"logId": log.ID},
-			bson.M{"logId": log.ShortID},
-		},
-	}
-
-	if len(kinds) > 0 {
-		for i := range kinds {
-			kinds[i] = strings.ToLower(kinds[i])
-		}
-
-		query["kind"] = bson.M{"$in": kinds}
-	}
-
-	posts, err := listPosts(query)
-	if err != nil {
-		return nil, err
-	}
-
-	sort.SliceStable(posts, func(i, j int) bool {
-		return posts[i].Position < posts[j].Position
-	})
-
-	return posts, nil
-}
-
-// NewPost creates a new post.
-func (log *Log) NewPost(time time.Time, kind, nick, text string) (Post, error) {
-	if kind == "" || nick == "" || text == "" {
-		return Post{}, errors.New("Missing/empty parameters")
-	}
-
-	postMutex.RLock()
-	defer postMutex.RUnlock()
-
-	position, err := counter.Next("next_post_id", log.ShortID)
-	if err != nil {
-		return Post{}, err
-	}
-
-	post := Post{
-		ID:       MakePostID(time),
-		Position: position,
-		LogID:    log.ShortID,
-		Time:     time,
-		Kind:     kind,
-		Nick:     nick,
-		Text:     text,
-	}
-
-	err = postCollection.Insert(post)
-	if err != nil {
-		return Post{}, err
-	}
-
-	return post, nil
-}
-
-// UpdateCharacters updates the character list
-func (log *Log) UpdateCharacters() error {
-	characterUpdateMutex.Lock()
-	defer characterUpdateMutex.Unlock()
-
-	posts, err := log.Posts()
-	if err != nil {
-		return err
-	}
-
-	added := make(map[string]bool)
-	removed := make(map[string]bool)
-	for _, post := range posts {
-		if post.Kind == "text" || post.Kind == "action" {
-			if strings.HasPrefix(post.Text, "(") || strings.Contains(post.Nick, "(") || strings.Contains(post.Nick, "[E]") {
-				continue
-			}
-
-			// Clean up the nick (remove possessive suffix, comma, formatting stuff)
-			if strings.HasSuffix(post.Nick, "'s") || strings.HasSuffix(post.Nick, "`s") {
-				post.Nick = post.Nick[:len(post.Nick)-2]
-			} else if strings.HasSuffix(post.Nick, "'") || strings.HasSuffix(post.Nick, "`") || strings.HasSuffix(post.Nick, ",") || strings.HasSuffix(post.Nick, "\x0f") {
-				post.Nick = post.Nick[:len(post.Nick)-1]
-			}
-
-			added[post.Nick] = true
-		}
-		if post.Kind == "chars" {
-			tokens := strings.Fields(post.Text)
-			for _, token := range tokens {
-				if strings.HasPrefix(token, "-") {
-					removed[token[1:]] = true
-				} else {
-					added[strings.Replace(token, "+", "", 1)] = true
-				}
-			}
-		}
-	}
-
-	nicks := make([]string, 0, len(added))
-	for nick := range added {
-		if added[nick] && !removed[nick] {
-			nicks = append(nicks, nick)
-		}
-	}
-
-	characters, err := character.ListNicks(nicks...)
-	if err != nil {
-		return err
-	}
-
-	characterIDs := make([]string, len(characters))
-	for i, char := range characters {
-		characterIDs[i] = char.ID
-	}
-
-	err = logsCollection.UpdateId(log.ID, bson.M{"$set": bson.M{"characterIds": characterIDs}})
-	if err != nil {
-		return err
-	}
-
-	for _, nick := range nicks {
-		found := false
-
-		for _, character := range characters {
-			if character.HasNick(nick) {
-				found = true
-				break
-			}
-		}
-
-		if !found {
-			addUnknownNick(nick)
-		}
-	}
-
-	log.CharacterIDs = characterIDs
-
-	return nil
-}
-
-// Remove removes the log and all associated posts from the database
-func (log *Log) Remove() error {
-	err := logsCollection.Remove(bson.M{"_id": log.ID})
-	if err != nil {
-		return err
-	}
-
-	_, err = postCollection.RemoveAll(bson.M{"$or": []bson.M{
-		bson.M{"logId": log.ID},
-		bson.M{"logId": log.ShortID},
-	}})
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func findLog(query interface{}) (Log, error) {
-	log := Log{}
-	err := logsCollection.Find(query).One(&log)
-	if err != nil {
-		return Log{}, err
-	}
-
-	return log, nil
-}
-
-func listLog(query interface{}, limit int) ([]Log, error) {
-	logs := make([]Log, 0, 64)
-	err := logsCollection.Find(query).Limit(limit).Sort("-date").All(&logs)
-	if err != nil {
-		return nil, err
-	}
-
-	return logs, nil
-}
-
-func iterLogs(query interface{}, limit int) *mgo.Iter {
-	return logsCollection.Find(query).Sort("-date").Limit(limit).Batch(8).Iter()
-}
-
-// MakeLogID generates log IDs that are of the format from logbot2, though it will break compatibility.
-func MakeLogID(date time.Time, channel string) string {
-	return fmt.Sprintf("%s%03d_%s", date.UTC().Format("2006-01-02_150405"), (date.Nanosecond() / int(time.Millisecond/time.Nanosecond)), channel[1:])
-}
-
-func init() {
-	store.HandleInit(func(db *mgo.Database) {
-		logsCollection = db.C("logbot3.logs")
-
-		logsCollection.EnsureIndexKey("date")
-		logsCollection.EnsureIndexKey("channel")
-		logsCollection.EnsureIndexKey("characterIds")
-		logsCollection.EnsureIndexKey("event")
-		logsCollection.EnsureIndex(mgo.Index{
-			Key: []string{"channel", "open"},
-		})
-		err := logsCollection.EnsureIndex(mgo.Index{
-			Key:      []string{"shortId"},
-			Unique:   true,
-			DropDups: true,
-		})
-		if err != nil {
-			log.Fatalln("init logbot3.logs:", err)
-		}
-	})
-}

model/log/post.go

@@ -1,198 +0,0 @@
-package log
-
-import (
-	"crypto/rand"
-	"encoding/binary"
-	"errors"
-	"log"
-	"strconv"
-	"time"
-
-	"git.aiterp.net/rpdata/api/internal/store"
-	"github.com/globalsign/mgo"
-	"github.com/globalsign/mgo/bson"
-)
-
-var postCollection *mgo.Collection
-
-// A Post is a part of a log file.
-type Post struct {
-	ID       string    `bson:"_id"`
-	LogID    string    `bson:"logId"`
-	Time     time.Time `bson:"time"`
-	Kind     string    `bson:"kind"`
-	Nick     string    `bson:"nick"`
-	Text     string    `bson:"text"`
-	Position int       `bson:"position"`
-}
-
-// Edit the post
-func (post *Post) Edit(time *time.Time, kind *string, nick *string, text *string) error {
-	changes := bson.M{}
-	changed := false
-	postCopy := *post
-
-	if time != nil && !time.IsZero() && !time.Equal(post.Time) {
-		changes["time"] = *time
-		changed = true
-		postCopy.Time = *time
-	}
-	if kind != nil && *kind != "" && *kind != post.Kind {
-		changes["kind"] = *kind
-		changed = true
-		postCopy.Kind = *kind
-	}
-	if nick != nil && *nick != "" && *nick != post.Nick {
-		changes["nick"] = *nick
-		changed = true
-		postCopy.Nick = *nick
-	}
-	if text != nil && *text != "" && *text != post.Text {
-		changes["text"] = *text
-		changed = true
-		postCopy.Text = *text
-	}
-
-	if !changed {
-		return nil
-	}
-
-	err := postCollection.UpdateId(post.ID, bson.M{"$set": changes})
-	if err != nil {
-		return err
-	}
-
-	*post = postCopy
-	return nil
-}
-
-// Move the post
-func (post *Post) Move(toPosition int) error {
-	if toPosition < 1 {
-		return errors.New("Invalid position")
-	}
-
-	postMutex.Lock()
-	defer postMutex.Unlock()
-
-	// To avoid problems, only allow target indices that are allowed. If it's 1, then there is bound to
-	// be a post at the position.
-	if toPosition > 1 {
-		existingPost := Post{}
-		err := postCollection.Find(bson.M{"logId": post.LogID, "position": toPosition}).One(&existingPost)
-
-		if err != nil || existingPost.Position != toPosition {
-			return errors.New("No post found at the position")
-		}
-	}
-
-	query := bson.M{"logId": post.LogID}
-	operation := bson.M{"$inc": bson.M{"position": 1}}
-
-	if toPosition < post.Position {
-		query["$and"] = []bson.M{
-			bson.M{"position": bson.M{"$gte": toPosition}},
-			bson.M{"position": bson.M{"$lt": post.Position}},
-		}
-	} else {
-		query["$and"] = []bson.M{
-			bson.M{"position": bson.M{"$gt": post.Position}},
-			bson.M{"position": bson.M{"$lte": toPosition}},
-		}
-
-		operation["$inc"] = bson.M{"position": -1}
-	}
-
-	_, err := postCollection.UpdateAll(query, operation)
-	if err != nil {
-		return errors.New("moving others: " + err.Error())
-	}
-
-	err = postCollection.UpdateId(post.ID, bson.M{"$set": bson.M{"position": toPosition}})
-	if err != nil {
-		return errors.New("moving: " + err.Error())
-	}
-
-	post.Position = toPosition
-
-	return nil
-}
-
-// FindPostID finds a log post by ID.
-func FindPostID(id string) (Post, error) {
-	return findPost(bson.M{"_id": id})
-}
-
-// ListPostIDs lists log posts by ID
-func ListPostIDs(ids ...string) ([]Post, error) {
-	return listPosts(bson.M{"_id": bson.M{"$in": ids}})
-}
-
-// RemovePost removes a post, moving all subsequent post up one position
-func RemovePost(id string) (Post, error) {
-	postMutex.Lock()
-	defer postMutex.Unlock()
-
-	post, err := findPost(bson.M{"_id": id})
-	if err != nil {
-		return Post{}, err
-	}
-
-	err = postCollection.RemoveId(id)
-	if err != nil {
-		return Post{}, err
-	}
-
-	_, err = postCollection.UpdateAll(bson.M{"logId": post.LogID, "position": bson.M{"$gt": post.Position}}, bson.M{"$inc": bson.M{"position": -1}})
-	if err != nil {
-		return Post{}, err
-	}
-
-	return post, nil
-}
-
-func findPost(query interface{}) (Post, error) {
-	post := Post{}
-	err := postCollection.Find(query).One(&post)
-	if err != nil {
-		return Post{}, err
-	}
-
-	return post, nil
-}
-
-func listPosts(query interface{}) ([]Post, error) {
-	posts := make([]Post, 0, 64)
-	err := postCollection.Find(query).All(&posts)
-	if err != nil {
-		return nil, err
-	}
-
-	return posts, nil
-}
-
-// MakePostID makes a random post ID
-func MakePostID(time time.Time) string {
-	data := make([]byte, 4)
-	rand.Read(data)
-
-	return "P" + strconv.FormatInt(time.UnixNano(), 36) + strconv.FormatInt(int64(binary.LittleEndian.Uint32(data)), 36)
-}
-
-func init() {
-	store.HandleInit(func(db *mgo.Database) {
-		postCollection = db.C("logbot3.posts")
-
-		postCollection.EnsureIndexKey("logId")
-		postCollection.EnsureIndexKey("time")
-		postCollection.EnsureIndexKey("kind")
-		postCollection.EnsureIndexKey("position")
-
-		err := postCollection.EnsureIndex(mgo.Index{
-			Key: []string{"$text:text"},
-		})
-		if err != nil {
-			log.Fatalln("init logbot3.logs:", err)
-		}
-	})
-}

model/log/unknownnick.go

@@ -1,42 +0,0 @@
-package log
-
-import (
-	"git.aiterp.net/rpdata/api/internal/store"
-	"github.com/globalsign/mgo"
-	"github.com/globalsign/mgo/bson"
-)
-
-var unknownConnection *mgo.Collection
-
-// An UnknownNick is a nick found by the character list updater that
-// does not exist. The score is the number of logs that nick was in, meaning
-// nicks with a higher score should be a high priority to be matched with
-// a character.
-type UnknownNick struct {
-	Nick  string `bson:"_id" json:"nick"`
-	Score int    `bson:"score" json:"score"`
-}
-
-// UnknownNicks gets all the unknown nicks from the last search.
-func UnknownNicks() ([]UnknownNick, error) {
-	nicks := make([]UnknownNick, 0, 256)
-	err := unknownConnection.Find(bson.M{}).Sort("-score").All(&nicks)
-
-	return nicks, err
-}
-
-func addUnknownNick(nick string) error {
-	_, err := unknownConnection.UpsertId(nick, bson.M{"$inc": bson.M{"score": 1}})
-	return err
-}
-
-func clearUnknownNicks() error {
-	_, err := unknownConnection.RemoveAll(bson.M{})
-	return err
-}
-
-func init() {
-	store.HandleInit(func(db *mgo.Database) {
-		unknownConnection = db.C("logbot3.unknown_nicks")
-	})
-}

model/log/updater.go

@@ -1,84 +0,0 @@
-package log
-
-import (
-	"sync"
-	"time"
-
-	"github.com/globalsign/mgo/bson"
-)
-
-var scheduleCharacterUpdate = func() func() {
-	var mutex sync.Mutex
-	var scheduled bool
-
-	return func() {
-		mutex.Lock()
-		if !scheduled {
-			go func() {
-				time.Sleep(time.Second * 60)
-
-				// If another comes along in the next 2-3 seconds, it should schedule a new
-				// round to avoid a character only appearing in half their logs.
-				mutex.Lock()
-				scheduled = false
-				mutex.Unlock()
-
-				UpdateAllCharacters()
-			}()
-
-			scheduled = true
-		}
-		mutex.Unlock()
-	}
-}()
-
-// ScheduleCharacterUpdate schedules a full update within the minute.
-// Subsequent calls within that time will not schedule anything. Even
-// if the operation takes a few seconds at most, it need not be ran often.
-func ScheduleCharacterUpdate() {
-	scheduleCharacterUpdate()
-}
-
-// UpdateCharacters is a shorthand for getting a log and updaing its characters
-func UpdateCharacters(logID string) error {
-	log, err := FindID(logID)
-	if err != nil {
-		return err
-	}
-
-	return log.UpdateCharacters()
-}
-
-// UpdateAllCharacters updates character list on all logs. This should
-// be done if one or more characters failed to be added.
-func UpdateAllCharacters() (updated int, err error) {
-	updated = 0
-
-	err = clearUnknownNicks()
-	if err != nil {
-		return
-	}
-
-	iter := iterLogs(bson.M{}, 0)
-	err = iter.Err()
-	if err != nil {
-		return
-	}
-
-	log := Log{}
-	for iter.Next(&log) {
-		err = log.UpdateCharacters()
-		if err != nil {
-			return
-		}
-
-		updated++
-	}
-
-	err = iter.Err()
-	if err != nil {
-		return
-	}
-
-	return
-}

model/story/chapter.go

@@ -1,111 +0,0 @@
-package story
-
-import (
-	"crypto/rand"
-	"encoding/binary"
-	"strconv"
-	"time"
-
-	"git.aiterp.net/rpdata/api/internal/store"
-	"github.com/globalsign/mgo"
-	"github.com/globalsign/mgo/bson"
-)
-
-var chapterCollection *mgo.Collection
-
-// A Chapter is a part of a story.
-type Chapter struct {
-	ID            string    `bson:"_id"`
-	StoryID       string    `bson:"storyId"`
-	Title         string    `bson:"title"`
-	Author        string    `bson:"author"`
-	Source        string    `bson:"source"`
-	CreatedDate   time.Time `bson:"createdDate"`
-	FictionalDate time.Time `bson:"fictionalDate,omitempty"`
-	EditedDate    time.Time `bson:"editedDate"`
-}
-
-// Edit edits a chapter, and updates EditedDate. While many Edit functions cheat if there's nothing to
-// change, this functill will due to EditedDate.
-func (chapter *Chapter) Edit(title, source *string, fictionalDate *time.Time) error {
-	now := time.Now()
-	changes := bson.M{"editedDate": now}
-	changed := *chapter
-	changed.EditedDate = now
-
-	if title != nil && *title != chapter.Title {
-		changes["title"] = *title
-		changed.Title = *title
-	}
-	if source != nil && *source != chapter.Source {
-		changes["source"] = *source
-		changed.Source = *source
-	}
-	if fictionalDate != nil && !fictionalDate.Equal(chapter.FictionalDate) {
-		changes["fictionalDate"] = *fictionalDate
-		changed.FictionalDate = *fictionalDate
-	}
-
-	err := chapterCollection.UpdateId(chapter.ID, bson.M{"$set": changes})
-	if err != nil {
-		return err
-	}
-
-	*chapter = changed
-
-	return nil
-}
-
-// Remove removes a chapter.
-func (chapter *Chapter) Remove() error {
-	return chapterCollection.RemoveId(chapter.ID)
-}
-
-// FindChapterID finds a chapter by its own ID
-func FindChapterID(id string) (Chapter, error) {
-	chapter := Chapter{}
-	err := chapterCollection.FindId(id).One(&chapter)
-
-	return chapter, err
-}
-
-// ListChapterStoryID lists all chapters for the story ID
-func ListChapterStoryID(storyID string) ([]Chapter, error) {
-	chapters := make([]Chapter, 0, 8)
-	err := chapterCollection.Find(bson.M{"storyId": storyID}).Sort("createdDate").All(&chapters)
-	if err != nil {
-		return nil, err
-	}
-
-	return chapters, nil
-}
-
-// makeChapterID makes a random chapter ID that's 24 characters long
-func makeChapterID() string {
-	result := "SC"
-	offset := 0
-	data := make([]byte, 32)
-
-	rand.Read(data)
-	for len(result) < 24 {
-		result += strconv.FormatUint(binary.LittleEndian.Uint64(data[offset:]), 36)
-		offset += 8
-
-		if offset >= 32 {
-			rand.Read(data)
-			offset = 0
-		}
-	}
-
-	return result[:24]
-}
-
-func init() {
-	store.HandleInit(func(db *mgo.Database) {
-		chapterCollection = db.C("story.chapters")
-
-		chapterCollection.EnsureIndexKey("storyId")
-		chapterCollection.EnsureIndexKey("author")
-		chapterCollection.EnsureIndexKey("createdDate")
-	})
-}

model/story/story.go

@@ -1,258 +0,0 @@
-package story
-
-import (
-	"crypto/rand"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"os"
-	"strconv"
-	"time"
-
-	"git.aiterp.net/rpdata/api/internal/store"
-	"github.com/globalsign/mgo"
-	"github.com/globalsign/mgo/bson"
-)
-
-var storyCollection *mgo.Collection
-
-// ErrTagAlreadyExists is an error returned by Story.AddTag
-var ErrTagAlreadyExists = errors.New("Tag already exists")
-
-// ErrTagNotExists is an error returned by Story.RemoveTag
-var ErrTagNotExists = errors.New("Tag does not exist")
-
-// A Story is user content that does not have a wiki-suitable format. Documents, new stories, short stories, and so on.
-// The story model is a container for multiple chapters this time, in contrast to the previous version.
-type Story struct {
-	ID            string    `bson:"_id"`
-	Author        string    `bson:"author"`
-	Name          string    `bson:"name"`
-	Category      string    `bson:"category"`
-	Open          bool      `bson:"open"`
-	Listed        bool      `bson:"listed"`
-	Tags          []Tag     `bson:"tags"`
-	CreatedDate   time.Time `bson:"createdDate"`
-	FictionalDate time.Time `bson:"fictionalDate,omitempty"`
-	UpdatedDate   time.Time `bson:"updatedDate"`
-}
-
-// AddTag adds a tag to the story. It returns ErrTagAlreadyExists if the tag is already there
-func (story *Story) AddTag(tag Tag) error {
-	for i := range story.Tags {
-		if story.Tags[i].Equal(tag) {
-			return ErrTagAlreadyExists
-		}
-	}
-
-	err := storyCollection.UpdateId(story.ID, bson.M{"$push": bson.M{"tags": tag}})
-	if err != nil {
-		return err
-	}
-
-	story.Tags = append(story.Tags, tag)
-
-	return nil
-}
-
-// RemoveTag removes a tag to the story. It returns ErrTagNotExists if the tag does not exist.
-func (story *Story) RemoveTag(tag Tag) error {
-	index := -1
-	for i := range story.Tags {
-		if story.Tags[i].Equal(tag) {
-			index = i
-			break
-		}
-	}
-	if index == -1 {
-		return ErrTagNotExists
-	}
-
-	err := storyCollection.UpdateId(story.ID, bson.M{"$pull": bson.M{"tags": tag}})
-	if err != nil {
-		return err
-	}
-
-	story.Tags = append(story.Tags[:index], story.Tags[index+1:]...)
-
-	return nil
-}
-
-// Edit edits the story, reflecting the new values in the story's struct values. If nothing will be
-// changed, it will silently return without a database roundtrip.
-func (story *Story) Edit(name, category *string, listed, open *bool, fictionalDate *time.Time) error {
-	changes := bson.M{}
-	changed := *story
-
-	if name != nil && *name != story.Name {
-		changes["name"] = *name
-		changed.Name = *name
-	}
-	if category != nil && *category != story.Category {
-		changes["category"] = *category
-		changed.Name = *category
-	}
-	if listed != nil && *listed != story.Listed {
-		changes["listed"] = *listed
-		changed.Listed = *listed
-	}
-	if open != nil && *open != story.Open {
-		changes["open"] = *open
-		changed.Open = *open
-	}
-	if fictionalDate != nil && !fictionalDate.Equal(story.FictionalDate) {
-		changes["fictionalDate"] = *fictionalDate
-		changed.FictionalDate = *fictionalDate
-	}
-
-	if len(changes) == 0 {
-		return nil
-	}
-
-	err := storyCollection.UpdateId(story.ID, bson.M{"$set": changes})
-	if err != nil {
-		return err
-	}
-
-	*story = changed
-
-	return nil
-}
-
-// Remove the story from the database
-func (story *Story) Remove() error {
-	return storyCollection.RemoveId(story.ID)
-}
-
-// Chapters calls ListChapterStoryID with the story's ID:
-func (story *Story) Chapters() ([]Chapter, error) {
-	return ListChapterStoryID(story.ID)
-}
-
-// AddChapter adds a chapter to the story. This does not enforce the `Open` setting, but it will log a warning if it
-// occurs
-func (story *Story) AddChapter(title, author, source string, createdDate, finctionalDate time.Time) (Chapter, error) {
-	if !story.Open && author != story.Author {
-		fmt.Fprintf(os.Stderr, "WARNING: AddChapter is breaking Open rules (story.id=%#+v, story.name=%#+v, chapter.author=%#+v, chapter.title=%#+v)", story.ID, story.Name, author, title)
-	}
-
-	chapter := Chapter{
-		ID:            makeChapterID(),
-		StoryID:       story.ID,
-		Title:         title,
-		Author:        author,
-		Source:        source,
-		CreatedDate:   createdDate,
-		FictionalDate: finctionalDate,
-		EditedDate:    createdDate,
-	}
-
-	err := chapterCollection.Insert(chapter)
-	if err != nil {
-		return Chapter{}, err
-	}
-
-	if createdDate.After(story.UpdatedDate) {
-		if err := storyCollection.UpdateId(story.ID, bson.M{"$set": bson.M{"updatedDate": createdDate}}); err == nil {
-			story.UpdatedDate = createdDate
-		}
-	}
-
-	return chapter, nil
-}
-
-// New creates a new story.
-func New(name, author, category string, listed, open bool, tags []Tag, createdDate, fictionalDate time.Time) (Story, error) {
-	story := Story{
-		ID:            makeStoryID(),
-		Name:          name,
-		Author:        author,
-		Category:      category,
-		Listed:        listed,
-		Open:          open,
-		Tags:          tags,
-		CreatedDate:   createdDate,
-		FictionalDate: fictionalDate,
-		UpdatedDate:   createdDate,
-	}
-
-	err := storyCollection.Insert(story)
-	if err != nil {
-		return Story{}, err
-	}
-
-	return story, nil
-}
-
-// FindID finds a story by ID
-func FindID(id string) (Story, error) {
-	story := Story{}
-	err := storyCollection.FindId(id).One(&story)
-
-	return story, err
-}
-
-// List lists stories by any non-zero criteria passed with it.
-func List(author string, tags []Tag, earliest, latest time.Time, limit int) ([]Story, error) {
-	query := bson.M{}
-
-	if author != "" {
-		query["author"] = author
-	}
-
-	if len(tags) > 0 {
-		query["tags"] = bson.M{"$in": tags}
-	}
-
-	if !earliest.IsZero() && !latest.IsZero() {
-		query["fictionalDate"] = bson.M{
-			"$gte": earliest,
-			"$lt":  latest,
-		}
-	} else if !latest.IsZero() {
-		query["fictionalDate"] = bson.M{
-			"$lt": latest,
-		}
-	} else if !earliest.IsZero() {
-		query["fictionalDate"] = bson.M{
-			"$gte": earliest,
-		}
-	}
-
-	stories := make([]Story, 0, 128)
-	err := storyCollection.Find(query).Limit(limit).All(&stories)
-
-	return stories, err
-}
-
-// makeStoryID makes a random story ID that's 16 characters long
-func makeStoryID() string {
-	result := "S"
-	offset := 0
-	data := make([]byte, 32)
-
-	rand.Read(data)
-	for len(result) < 16 {
-		result += strconv.FormatUint(binary.LittleEndian.Uint64(data[offset:]), 36)
-		offset += 8
-
-		if offset >= 32 {
-			rand.Read(data)
-			offset = 0
-		}
-	}
-
-	return result[:16]
-}
-
-func init() {
-	store.HandleInit(func(db *mgo.Database) {
-		storyCollection = db.C("story.stories")
-
-		storyCollection.EnsureIndexKey("tags")
-		storyCollection.EnsureIndexKey("author")
-		storyCollection.EnsureIndexKey("updatedDate")
-		storyCollection.EnsureIndexKey("fictionalDate")
-		storyCollection.EnsureIndexKey("listed")
-	})
-}

model/story/tag.go

@@ -1,36 +0,0 @@
-package story
-
-import (
-	"sort"
-	"strings"
-
-	"github.com/globalsign/mgo/bson"
-)
-
-// A Tag associates a story with other content, like other stories, logs and more.
-type Tag struct {
-	Kind string `bson:"kind"`
-	Name string `bson:"name"`
-}
-
-// Equal returns true if the tags match one another.
-func (tag *Tag) Equal(other Tag) bool {
-	return tag.Kind == other.Kind && tag.Name == other.Name
-}
-
-// ListTags lists all tags
-func ListTags() ([]Tag, error) {
-	tags := make([]Tag, 0, 64)
-	err := storyCollection.Find(bson.M{"listed": true, "tags": bson.M{"$ne": nil}}).Distinct("tags", &tags)
-
-	sort.Slice(tags, func(i, j int) bool {
-		kindCmp := strings.Compare(tags[i].Kind, tags[j].Kind)
-		if kindCmp != 0 {
-			return kindCmp < 0
-		}
-
-		return strings.Compare(tags[i].Name, tags[j].Name) < 0
-	})
-
-	return tags, err
-}

models/change-model.go

@@ -0,0 +1,59 @@
+package models
+
+import (
+	"fmt"
+	"io"
+	"strconv"
+)
+
+// ChangeModel describes a model related to the change.
+type ChangeModel string
+
+const (
+	// ChangeModelCharacter is a value of ChangeModel
+	ChangeModelCharacter ChangeModel = "Character"
+	// ChangeModelChannel is a value of ChangeModel
+	ChangeModelChannel ChangeModel = "Channel"
+	// ChangeModelLog is a value of ChangeModel
+	ChangeModelLog ChangeModel = "Log"
+	// ChangeModelPost is a value of ChangeModel
+	ChangeModelPost ChangeModel = "Post"
+	// ChangeModelStory is a value of ChangeModel
+	ChangeModelStory ChangeModel = "Story"
+	// ChangeModelTag is a value of ChangeModel
+	ChangeModelTag ChangeModel = "Tag"
+	// ChangeModelChapter is a value of ChangeModel
+	ChangeModelChapter ChangeModel = "Chapter"
+)
+
+// IsValid returns true if the underlying string is one of the correct values.
+func (e ChangeModel) IsValid() bool {
+	switch e {
+	case ChangeModelCharacter, ChangeModelChannel, ChangeModelLog, ChangeModelPost, ChangeModelStory, ChangeModelTag, ChangeModelChapter:
+		return true
+	}
+	return false
+}
+
+func (e ChangeModel) String() string {
+	return string(e)
+}
+
+// UnmarshalGQL unmarshals the underlying graphql value.
+func (e *ChangeModel) UnmarshalGQL(v interface{}) error {
+	str, ok := v.(string)
+	if !ok {
+		return fmt.Errorf("enums must be strings")
+	}
+
+	*e = ChangeModel(str)
+	if !e.IsValid() {
+		return fmt.Errorf("%s is not a valid ChangeModel", str)
+	}
+	return nil
+}
+
+// MarshalGQL marshals the underlying graphql value.
+func (e ChangeModel) MarshalGQL(w io.Writer) {
+	fmt.Fprint(w, strconv.Quote(e.String()))
+}

models/change.go

@@ -0,0 +1,57 @@
+package models
+
+import "time"
+
+// Change represents a change in the rpdata history through the API.
+type Change struct {
+	ID     string      `bson:"_id"`
+	Model  ChangeModel `bson:"model"`
+	Op     string      `bson:"op"`
+	Author string      `bson:"author"`
+	Listed bool        `bson:"listed"`
+	Keys   []ChangeKey `bson:"keys"`
+	Date   time.Time   `bson:"date"`
+
+	Logs       []Log       `bson:"logs"`
+	Characters []Character `bson:"characters"`
+	Channels   []Channel   `bson:"channels"`
+	Posts      []Post      `bson:"posts"`
+	Stories    []Story     `bson:"stories"`
+	Tags       []Tag       `bson:"tags"`
+	Chapters   []Chapter   `bson:"chapters"`
+}
+
+// ChangeKey is a key for a change that can be used when subscribing to them.
+type ChangeKey struct {
+	Model ChangeModel `bson:"model"`
+	ID    string      `bson:"id"`
+}
+
+// Objects makes a combined, mixed array of all the models stored in this change.
+func (change *Change) Objects() []interface{} {
+	data := make([]interface{}, 0, len(change.Logs)+len(change.Characters)+len(change.Channels)+len(change.Posts)+len(change.Stories)+len(change.Tags)+len(change.Chapters))
+
+	for _, log := range change.Logs {
+		data = append(data, log)
+	}
+	for _, channel := range change.Channels {
+		data = append(data, channel)
+	}
+	for _, character := range change.Characters {
+		data = append(data, character)
+	}
+	for _, post := range change.Posts {
+		data = append(data, post)
+	}
+	for _, story := range change.Stories {
+		data = append(data, story)
+	}
+	for _, tag := range change.Tags {
+		data = append(data, tag)
+	}
+	for _, chapter := range change.Chapters {
+		data = append(data, chapter)
+	}
+
+	return data
+}

models/changekeys/all.go

@@ -0,0 +1,8 @@
+package changekeys
+
+import "git.aiterp.net/rpdata/api/models"
+
+// All makes a changelog that's (model, "*"). It's a helper to standardize it.
+func All(model string) models.ChangeKey {
+	return models.ChangeKey{Model: models.ChangeModel(model), ID: "*"}
+}

models/changekeys/listed.go

@@ -0,0 +1,13 @@
+package changekeys
+
+import "git.aiterp.net/rpdata/api/models"
+
+// Listed is a helper for cases like []models.ChangeKey{changekeys.All("Logs"), changekeys.One(log)}
+func Listed(objects ...interface{}) []models.ChangeKey {
+	keys := Many(objects)
+	if len(keys) == 0 {
+		return nil
+	}
+
+	return append(keys, All(keys[0].Model.String()))
+}

models/changekeys/many.go

@@ -0,0 +1,27 @@
+package changekeys
+
+import (
+	"reflect"
+
+	"git.aiterp.net/rpdata/api/models"
+)
+
+// Many returns a key set matching the input objects, but without the asterisk key. You may pass
+// a slice as an argument, for example (log, posts) and it will be flattened
+func Many(objects ...interface{}) []models.ChangeKey {
+	keys := make([]models.ChangeKey, 0, len(objects))
+	for _, object := range objects {
+		if v := reflect.ValueOf(object); v.Kind() == reflect.Slice {
+			elems := make([]interface{}, 0, v.Len())
+			for i := 0; i < v.Len(); i++ {
+				elems = append(elems, v.Index(i).Interface())
+			}
+
+			keys = append(keys, Many(elems...)...)
+		} else {
+			keys = append(keys, One(object))
+		}
+	}
+
+	return keys
+}