10 changed files with 0 additions and 1370 deletions
-
159model/channel/channel.go
-
11model/log/filter.go
-
396model/log/log.go
-
198model/log/post.go
-
42model/log/unknownnick.go
-
84model/log/updater.go
-
111model/story/chapter.go
-
275model/story/story.go
-
58model/story/tag-kind.go
-
36model/story/tag.go
@ -1,159 +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"` |
|||
EventName string `bson:"event,omitempty"` |
|||
LocationName string `bson:"location,omitempty"` |
|||
} |
|||
|
|||
// Filter for searching
|
|||
type Filter struct { |
|||
Logged *bool `json:"logged"` |
|||
EventName string `json:"eventName"` |
|||
LocationName string `json:"locationName"` |
|||
} |
|||
|
|||
// 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.EventName != *event { |
|||
changes["event"] = *event |
|||
changed.EventName = *event |
|||
} |
|||
if location != nil && channel.LocationName != *location { |
|||
changes["location"] = *location |
|||
changed.LocationName = *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, |
|||
EventName: event, |
|||
LocationName: 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(filter *Filter) ([]Channel, error) { |
|||
query := bson.M{} |
|||
|
|||
if filter != nil { |
|||
if filter.Logged != nil { |
|||
query["logged"] = *filter.Logged |
|||
} |
|||
if filter.EventName != "" { |
|||
query["eventName"] = filter.EventName |
|||
} |
|||
if filter.LocationName != "" { |
|||
query["locationName"] = filter.LocationName |
|||
} |
|||
} |
|||
|
|||
channels := make([]Channel, 0, 128) |
|||
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") |
|||
}) |
|||
} |
|||
@ -1,11 +0,0 @@ |
|||
package log |
|||
|
|||
// Filter for the List() function
|
|||
type Filter struct { |
|||
Search *string |
|||
Characters *[]string |
|||
Channels *[]string |
|||
Events *[]string |
|||
Open *bool |
|||
Limit int |
|||
} |
|||
@ -1,396 +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"` |
|||
ChannelName 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, |
|||
ChannelName: 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(filter *Filter) ([]Log, error) { |
|||
query := bson.M{} |
|||
limit := 0 |
|||
|
|||
if filter != nil { |
|||
// Run a text search
|
|||
if filter.Search != nil { |
|||
searchResults := make([]string, 0, 32) |
|||
|
|||
postMutex.RLock() |
|||
err := postCollection.Find(bson.M{"$text": bson.M{"$search": *filter.Search}}).Distinct("logId", &searchResults) |
|||
if err != nil { |
|||
return nil, err |
|||
} |
|||
postMutex.RUnlock() |
|||
|
|||
// 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 filter.Channels != nil { |
|||
query["channel"] = bson.M{"$in": *filter.Channels} |
|||
} |
|||
if filter.Events != nil { |
|||
query["event"] = bson.M{"$in": *filter.Events} |
|||
} |
|||
|
|||
// Find logs including all of the specified character IDs.
|
|||
if filter.Characters != nil { |
|||
query["characterIds"] = bson.M{"$all": *filter.Characters} |
|||
} |
|||
|
|||
// Limit to only open logs
|
|||
if filter.Open != nil { |
|||
query["open"] = *filter.Open |
|||
} |
|||
|
|||
// Set the limit from the filter
|
|||
limit = filter.Limit |
|||
} |
|||
|
|||
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 |
|||
} |
|||
|
|||
// Characters get all the characters for the character IDs stored in the
|
|||
// log file.
|
|||
func (log *Log) Characters() ([]character.Character, error) { |
|||
return character.ListIDs(log.CharacterIDs...) |
|||
} |
|||
|
|||
// Channel gets the channel.
|
|||
func (log *Log) Channel() (channel.Channel, error) { |
|||
return channel.FindName(log.ChannelName) |
|||
} |
|||
|
|||
// 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([]string{"action", "text", "chars"}) |
|||
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) |
|||
} |
|||
}) |
|||
} |
|||
@ -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) |
|||
} |
|||
}) |
|||
} |
|||
@ -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") |
|||
}) |
|||
} |
|||
@ -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 |
|||
} |
|||
@ -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") |
|||
}) |
|||
} |
|||
@ -1,275 +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, category string, tags []Tag, earliest, latest time.Time, unlisted bool, open *bool, limit int) ([]Story, error) { |
|||
query := bson.M{} |
|||
|
|||
if author != "" { |
|||
query["author"] = author |
|||
} |
|||
|
|||
if category != "" { |
|||
query["category"] = category |
|||
} |
|||
|
|||
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, |
|||
} |
|||
} |
|||
|
|||
if unlisted { |
|||
query["listed"] = false |
|||
} |
|||
|
|||
if open != nil { |
|||
query["open"] = *open |
|||
} |
|||
|
|||
size := limit |
|||
if size == 0 { |
|||
size = 128 |
|||
} |
|||
stories := make([]Story, 0, size) |
|||
|
|||
err := storyCollection.Find(query).Limit(limit).Sort("-updatedDate").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") |
|||
}) |
|||
} |
|||
@ -1,58 +0,0 @@ |
|||
package story |
|||
|
|||
import ( |
|||
"fmt" |
|||
"io" |
|||
) |
|||
|
|||
// TagKind represents the kind of tags.
|
|||
type TagKind string |
|||
|
|||
const ( |
|||
// TagKindOrganization is a tag kind, see GraphQL documentation.
|
|||
TagKindOrganization TagKind = "Organization" |
|||
|
|||
// TagKindCharacter is a tag kind, see GraphQL documentation.
|
|||
TagKindCharacter TagKind = "Character" |
|||
|
|||
// TagKindLocation is a tag kind, see GraphQL documentation.
|
|||
TagKindLocation TagKind = "Location" |
|||
|
|||
// TagKindEvent is a tag kind, see GraphQL documentation.
|
|||
TagKindEvent TagKind = "Event" |
|||
|
|||
// TagKindSeries is a tag kind, see GraphQL documentation.
|
|||
TagKindSeries TagKind = "Series" |
|||
) |
|||
|
|||
// IsValid returns true if the TagKind is one of the constants
|
|||
func (e TagKind) IsValid() bool { |
|||
switch e { |
|||
case TagKindOrganization, TagKindCharacter, TagKindLocation, TagKindEvent, TagKindSeries: |
|||
return true |
|||
} |
|||
return false |
|||
} |
|||
|
|||
func (e TagKind) String() string { |
|||
return string(e) |
|||
} |
|||
|
|||
// UnmarshalGQL unmarshals
|
|||
func (e *TagKind) UnmarshalGQL(v interface{}) error { |
|||
str, ok := v.(string) |
|||
if !ok { |
|||
return fmt.Errorf("enums must be strings") |
|||
} |
|||
|
|||
*e = TagKind(str) |
|||
if !e.IsValid() { |
|||
return fmt.Errorf("%s is not a valid TagKind", str) |
|||
} |
|||
return nil |
|||
} |
|||
|
|||
// MarshalGQL turns it into a JSON string
|
|||
func (e TagKind) MarshalGQL(w io.Writer) { |
|||
fmt.Fprint(w, "\""+e.String(), "\"") |
|||
} |
|||
@ -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 TagKind `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(string(tags[i].Kind), string(tags[j].Kind)) |
|||
if kindCmp != 0 { |
|||
return kindCmp < 0 |
|||
} |
|||
|
|||
return strings.Compare(tags[i].Name, tags[j].Name) < 0 |
|||
}) |
|||
|
|||
return tags, err |
|||
} |
|||
Write
Preview
Loading…
Cancel
Save
Reference in new issue