Added arn to the main repository

arn/EditLogEntry.go

@@ -0,0 +1,168 @@
+package arn
+
+import (
+	"reflect"
+	"sort"
+
+	"github.com/aerogo/nano"
+)
+
+// EditLogEntry is an entry in the editor log.
+type EditLogEntry struct {
+	ID         string `json:"id"`
+	UserID     string `json:"userId"`
+	Action     string `json:"action"`
+	ObjectType string `json:"objectType"` // The typename of what was edited
+	ObjectID   string `json:"objectId"`   // The ID of what was edited
+	Key        string `json:"key"`
+	OldValue   string `json:"oldValue"`
+	NewValue   string `json:"newValue"`
+	Created    string `json:"created"`
+}
+
+// NewEditLogEntry ...
+func NewEditLogEntry(userID, action, objectType, objectID, key, oldValue, newValue string) *EditLogEntry {
+	return &EditLogEntry{
+		ID:         GenerateID("EditLogEntry"),
+		UserID:     userID,
+		Action:     action,
+		ObjectType: objectType,
+		ObjectID:   objectID,
+		Key:        key,
+		OldValue:   oldValue,
+		NewValue:   newValue,
+		Created:    DateTimeUTC(),
+	}
+}
+
+// User returns the user the log entry belongs to.
+func (entry *EditLogEntry) User() *User {
+	user, _ := GetUser(entry.UserID)
+	return user
+}
+
+// Object returns the object the log entry refers to.
+func (entry *EditLogEntry) Object() interface{} {
+	obj, _ := DB.Get(entry.ObjectType, entry.ObjectID)
+	return obj
+}
+
+// EditorScore returns the editing score for this log entry.
+func (entry *EditLogEntry) EditorScore() int {
+	switch entry.Action {
+	case "create":
+		obj, err := DB.Get(entry.ObjectType, entry.ObjectID)
+
+		if err != nil {
+			return 0
+		}
+
+		v := reflect.Indirect(reflect.ValueOf(obj))
+		isDraft := v.FieldByName("IsDraft")
+
+		if isDraft.Kind() == reflect.Bool && isDraft.Bool() {
+			// No score for drafts
+			return 0
+		}
+
+		return 4
+
+	case "edit":
+		score := 4
+
+		// Bonus score for editing anime
+		if entry.ObjectType == "Anime" {
+			score++
+
+			// Bonus score for editing anime synopsis
+			if entry.Key == "Summary" || entry.Key == "Synopsis" {
+				score++
+			}
+		}
+
+		return score
+
+	case "delete", "arrayRemove":
+		return 3
+
+	case "arrayAppend":
+		return 0
+	}
+
+	return 0
+}
+
+// ActionHumanReadable returns the human readable version of the action.
+func (entry *EditLogEntry) ActionHumanReadable() string {
+	switch entry.Action {
+	case "create":
+		return "Created"
+
+	case "edit":
+		return "Edited"
+
+	case "delete":
+		return "Deleted"
+
+	case "arrayAppend":
+		return "Added an element"
+
+	case "arrayRemove":
+		return "Removed an element"
+
+	default:
+		return entry.Action
+	}
+}
+
+// StreamEditLogEntries returns a stream of all log entries.
+func StreamEditLogEntries() <-chan *EditLogEntry {
+	channel := make(chan *EditLogEntry, nano.ChannelBufferSize)
+
+	go func() {
+		for obj := range DB.All("EditLogEntry") {
+			channel <- obj.(*EditLogEntry)
+		}
+
+		close(channel)
+	}()
+
+	return channel
+}
+
+// AllEditLogEntries returns a slice of all log entries.
+func AllEditLogEntries() []*EditLogEntry {
+	all := make([]*EditLogEntry, 0, DB.Collection("EditLogEntry").Count())
+
+	stream := StreamEditLogEntries()
+
+	for obj := range stream {
+		all = append(all, obj)
+	}
+
+	return all
+}
+
+// FilterEditLogEntries filters all log entries by a custom function.
+func FilterEditLogEntries(filter func(*EditLogEntry) bool) []*EditLogEntry {
+	var filtered []*EditLogEntry
+
+	channel := DB.All("EditLogEntry")
+
+	for obj := range channel {
+		realObject := obj.(*EditLogEntry)
+
+		if filter(realObject) {
+			filtered = append(filtered, realObject)
+		}
+	}
+
+	return filtered
+}
+
+// SortEditLogEntriesLatestFirst puts the latest entries on top.
+func SortEditLogEntriesLatestFirst(entries []*EditLogEntry) {
+	sort.Slice(entries, func(i, j int) bool {
+		return entries[i].Created > entries[j].Created
+	})
+}