Moved channels to new system, fixed change insert not working.

services/changes.go

@@ -42,6 +42,7 @@ func (s *ChangeService) Submit(ctx context.Context, model models.ChangeModel, op
 		Author: token.UserID,
 		Listed: listed,
 		Keys:   keys,
+		Date:   time.Now(),
 	}
 
 	for _, obj := range objects {
@@ -115,7 +116,9 @@ func (s *ChangeService) loop() {
 
 		change, err := s.changes.Insert(timeout, *change)
 		if err != nil {
-			log.Println("Failed to submit change:")
+			log.Println("Failed to insert change:")
+		} else {
+			log.Println("Change", change.ID, "inserted.")
 		}
 
 		s.mutex.Lock()

services/channels.go

@@ -0,0 +1,137 @@
+package services
+
+import (
+	"context"
+	"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/repositories"
+	"git.aiterp.net/rpdata/api/services/loaders"
+)
+
+// ChannelService is an application service for dealing with channels.
+type ChannelService struct {
+	channels      repositories.ChannelRepository
+	loader        *loaders.ChannelLoader
+	changeService *ChangeService
+}
+
+func (s *ChannelService) Find(ctx context.Context, id string) (*models.Channel, error) {
+	return s.loader.Load(id)
+}
+
+func (s *ChannelService) List(ctx context.Context, filter models.ChannelFilter) ([]*models.Channel, error) {
+	if filter.LocationName != nil && filter.EventName != nil && filter.Logged != nil && filter.Limit == 0 && len(filter.Names) > 0 {
+		channels, errs := s.loader.LoadAll(filter.Names)
+		for _, err := range errs {
+			if err != nil && err != repositories.ErrNotFound {
+				return nil, err
+			}
+		}
+
+		output := make([]*models.Channel, 0, len(channels))
+		for _, channel := range channels {
+			if channel == nil {
+				continue
+			}
+			output = append(output, channel)
+		}
+
+		return output, nil
+	}
+
+	return s.channels.List(ctx, filter)
+}
+
+func (s *ChannelService) Create(ctx context.Context, name string, logged, hub bool, eventName, locationName string) (*models.Channel, error) {
+	err := auth.CheckPermission(ctx, "add", &models.Channel{})
+	if err != nil {
+		return nil, err
+	}
+
+	channel, err := s.channels.Insert(ctx, models.Channel{
+		Name:         name,
+		Logged:       logged,
+		Hub:          hub,
+		EventName:    eventName,
+		LocationName: locationName,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	s.changeService.Submit(ctx, "Channel", "add", true, changekeys.Listed(channel), channel)
+
+	return channel, nil
+}
+
+func (s *ChannelService) Ensure(ctx context.Context, name string) (*models.Channel, error) {
+	err := auth.CheckPermission(ctx, "add", &models.Channel{})
+	if err != nil {
+		return nil, err
+	}
+
+	channel, err := s.channels.Find(ctx, name)
+	if err != nil {
+		channel, err = s.channels.Insert(ctx, models.Channel{
+			Name:         name,
+			Logged:       false,
+			Hub:          false,
+			EventName:    "",
+			LocationName: "",
+		})
+		if err != nil {
+			return nil, err
+		}
+
+		s.changeService.Submit(ctx, "Channel", "add", true, changekeys.Listed(channel), channel)
+	}
+
+	return channel, nil
+}
+
+func (s *ChannelService) Update(ctx context.Context, name string, update models.ChannelUpdate) (*models.Channel, error) {
+	channel, err := s.channels.Find(ctx, name)
+	if err != nil {
+		return nil, err
+	}
+
+	err = auth.CheckPermission(ctx, "edit", channel)
+	if err != nil {
+		return nil, err
+	}
+
+	channel, err = s.channels.Update(ctx, *channel, update)
+	if err != nil {
+		return nil, err
+	}
+
+	s.loader.Clear(channel.Name)
+
+	s.changeService.Submit(ctx, "Channel", "edit", true, changekeys.Listed(channel), channel)
+
+	return channel, nil
+}
+
+func (s *ChannelService) Delete(ctx context.Context, name string) (*models.Channel, error) {
+	channel, err := s.channels.Find(ctx, name)
+	if err != nil {
+		return nil, err
+	}
+
+	err = auth.CheckPermission(ctx, "remove", channel)
+	if err != nil {
+		return nil, err
+	}
+
+	err = s.channels.Remove(ctx, *channel)
+	if err != nil {
+		return nil, err
+	}
+
+	s.changeService.Submit(ctx, "Channel", "remove", true, changekeys.Listed(channel), channel)
+
+	s.loader.Clear(channel.Name)
+
+	return channel, nil
+}

services/characters.go

@@ -199,7 +199,6 @@ func (s *CharacterService) Delete(ctx context.Context, id string) (*models.Chara
 	}
 
 	s.loader.Clear(character.ID)
-	s.loader.Prime(character.ID, character)
 
 	s.changeService.Submit(ctx, "Character", "remove", true, changekeys.Listed(character), character)
 

services/loaders/channelloader_gen.go

@@ -0,0 +1,224 @@
+// Code generated by github.com/vektah/dataloaden, DO NOT EDIT.
+
+package loaders
+
+import (
+	"sync"
+	"time"
+
+	"git.aiterp.net/rpdata/api/models"
+)
+
+// ChannelLoaderConfig captures the config to create a new ChannelLoader
+type ChannelLoaderConfig struct {
+	// Fetch is a method that provides the data for the loader
+	Fetch func(keys []string) ([]*models.Channel, []error)
+
+	// Wait is how long wait before sending a batch
+	Wait time.Duration
+
+	// MaxBatch will limit the maximum number of keys to send in one batch, 0 = not limit
+	MaxBatch int
+}
+
+// NewChannelLoader creates a new ChannelLoader given a fetch, wait, and maxBatch
+func NewChannelLoader(config ChannelLoaderConfig) *ChannelLoader {
+	return &ChannelLoader{
+		fetch:    config.Fetch,
+		wait:     config.Wait,
+		maxBatch: config.MaxBatch,
+	}
+}
+
+// ChannelLoader batches and caches requests
+type ChannelLoader struct {
+	// this method provides the data for the loader
+	fetch func(keys []string) ([]*models.Channel, []error)
+
+	// how long to done before sending a batch
+	wait time.Duration
+
+	// this will limit the maximum number of keys to send in one batch, 0 = no limit
+	maxBatch int
+
+	// INTERNAL
+
+	// lazily created cache
+	cache map[string]*models.Channel
+
+	// the current batch. keys will continue to be collected until timeout is hit,
+	// then everything will be sent to the fetch method and out to the listeners
+	batch *channelLoaderBatch
+
+	// mutex to prevent races
+	mu sync.Mutex
+}
+
+type channelLoaderBatch struct {
+	keys    []string
+	data    []*models.Channel
+	error   []error
+	closing bool
+	done    chan struct{}
+}
+
+// Load a Channel by key, batching and caching will be applied automatically
+func (l *ChannelLoader) Load(key string) (*models.Channel, error) {
+	return l.LoadThunk(key)()
+}
+
+// LoadThunk returns a function that when called will block waiting for a Channel.
+// This method should be used if you want one goroutine to make requests to many
+// different data loaders without blocking until the thunk is called.
+func (l *ChannelLoader) LoadThunk(key string) func() (*models.Channel, error) {
+	l.mu.Lock()
+	if it, ok := l.cache[key]; ok {
+		l.mu.Unlock()
+		return func() (*models.Channel, error) {
+			return it, nil
+		}
+	}
+	if l.batch == nil {
+		l.batch = &channelLoaderBatch{done: make(chan struct{})}
+	}
+	batch := l.batch
+	pos := batch.keyIndex(l, key)
+	l.mu.Unlock()
+
+	return func() (*models.Channel, error) {
+		<-batch.done
+
+		var data *models.Channel
+		if pos < len(batch.data) {
+			data = batch.data[pos]
+		}
+
+		var err error
+		// its convenient to be able to return a single error for everything
+		if len(batch.error) == 1 {
+			err = batch.error[0]
+		} else if batch.error != nil {
+			err = batch.error[pos]
+		}
+
+		if err == nil {
+			l.mu.Lock()
+			l.unsafeSet(key, data)
+			l.mu.Unlock()
+		}
+
+		return data, err
+	}
+}
+
+// LoadAll fetches many keys at once. It will be broken into appropriate sized
+// sub batches depending on how the loader is configured
+func (l *ChannelLoader) LoadAll(keys []string) ([]*models.Channel, []error) {
+	results := make([]func() (*models.Channel, error), len(keys))
+
+	for i, key := range keys {
+		results[i] = l.LoadThunk(key)
+	}
+
+	channels := make([]*models.Channel, len(keys))
+	errors := make([]error, len(keys))
+	for i, thunk := range results {
+		channels[i], errors[i] = thunk()
+	}
+	return channels, errors
+}
+
+// LoadAllThunk returns a function that when called will block waiting for a Channels.
+// This method should be used if you want one goroutine to make requests to many
+// different data loaders without blocking until the thunk is called.
+func (l *ChannelLoader) LoadAllThunk(keys []string) func() ([]*models.Channel, []error) {
+	results := make([]func() (*models.Channel, error), len(keys))
+	for i, key := range keys {
+		results[i] = l.LoadThunk(key)
+	}
+	return func() ([]*models.Channel, []error) {
+		channels := make([]*models.Channel, len(keys))
+		errors := make([]error, len(keys))
+		for i, thunk := range results {
+			channels[i], errors[i] = thunk()
+		}
+		return channels, errors
+	}
+}
+
+// Prime the cache with the provided key and value. If the key already exists, no change is made
+// and false is returned.
+// (To forcefully prime the cache, clear the key first with loader.clear(key).prime(key, value).)
+func (l *ChannelLoader) Prime(key string, value *models.Channel) bool {
+	l.mu.Lock()
+	var found bool
+	if _, found = l.cache[key]; !found {
+		// make a copy when writing to the cache, its easy to pass a pointer in from a loop var
+		// and end up with the whole cache pointing to the same value.
+		cpy := *value
+		l.unsafeSet(key, &cpy)
+	}
+	l.mu.Unlock()
+	return !found
+}
+
+// Clear the value at key from the cache, if it exists
+func (l *ChannelLoader) Clear(key string) {
+	l.mu.Lock()
+	delete(l.cache, key)
+	l.mu.Unlock()
+}
+
+func (l *ChannelLoader) unsafeSet(key string, value *models.Channel) {
+	if l.cache == nil {
+		l.cache = map[string]*models.Channel{}
+	}
+	l.cache[key] = value
+}
+
+// keyIndex will return the location of the key in the batch, if its not found
+// it will add the key to the batch
+func (b *channelLoaderBatch) keyIndex(l *ChannelLoader, key string) int {
+	for i, existingKey := range b.keys {
+		if key == existingKey {
+			return i
+		}
+	}
+
+	pos := len(b.keys)
+	b.keys = append(b.keys, key)
+	if pos == 0 {
+		go b.startTimer(l)
+	}
+
+	if l.maxBatch != 0 && pos >= l.maxBatch-1 {
+		if !b.closing {
+			b.closing = true
+			l.batch = nil
+			go b.end(l)
+		}
+	}
+
+	return pos
+}
+
+func (b *channelLoaderBatch) startTimer(l *ChannelLoader) {
+	time.Sleep(l.wait)
+	l.mu.Lock()
+
+	// we must have hit a batch limit and are already finalizing this batch
+	if b.closing {
+		l.mu.Unlock()
+		return
+	}
+
+	l.batch = nil
+	l.mu.Unlock()
+
+	b.end(l)
+}
+
+func (b *channelLoaderBatch) end(l *ChannelLoader) {
+	b.data, b.error = l.fetch(b.keys)
+	close(b.done)
+}

services/loaders/loaders.go

@@ -8,6 +8,7 @@ import (
 )
 
 //go:generate go run github.com/vektah/dataloaden CharacterLoader string *git.aiterp.net/rpdata/api/models.Character
+//go:generate go run github.com/vektah/dataloaden ChannelLoader string *git.aiterp.net/rpdata/api/models.Channel
 
 // CharacterLoaderFromRepository creates a new CharacterLoader
 func CharacterLoaderFromRepository(repo repositories.CharacterRepository) *CharacterLoader {
@@ -31,7 +32,6 @@ func CharacterLoaderFromRepository(repo repositories.CharacterRepository) *Chara
 			}
 
 			charMap := make(map[string]*models.Character, len(keys))
-
 			for _, character := range characters {
 				charMap[character.ID] = character
 			}
@@ -51,3 +51,45 @@ func CharacterLoaderFromRepository(repo repositories.CharacterRepository) *Chara
 		},
 	}
 }
+
+// ChannelLoaderFromRepository creates a new CharacterLoader
+func ChannelLoaderFromRepository(repo repositories.ChannelRepository) *ChannelLoader {
+	return &ChannelLoader{
+		wait:     time.Millisecond * 1,
+		maxBatch: 100,
+		fetch: func(keys []string) ([]*models.Channel, []error) {
+			timeout, cancel := context.WithTimeout(context.Background(), time.Second*15)
+			defer cancel()
+
+			channels, err := repo.List(timeout, models.ChannelFilter{
+				Names: keys,
+			})
+			if err != nil {
+				errs := make([]error, len(keys))
+				for i := range errs {
+					errs[i] = err
+				}
+
+				return nil, errs
+			}
+
+			channelMap := make(map[string]*models.Channel, len(keys))
+			for _, channel := range channels {
+				channelMap[channel.Name] = channel
+			}
+
+			results := make([]*models.Channel, len(keys))
+			errs := make([]error, len(keys))
+
+			for i, key := range keys {
+				if channel, ok := channelMap[key]; ok {
+					results[i] = channel
+				} else {
+					errs[i] = repositories.ErrNotFound
+				}
+			}
+
+			return results, errs
+		},
+	}
+}

services/logs.go

@@ -13,9 +13,10 @@ import (
 )
 
 type LogService struct {
-	logs          repositories.LogRepository
-	posts         repositories.PostRepository
-	changeService *ChangeService
+	logs           repositories.LogRepository
+	posts          repositories.PostRepository
+	changeService  *ChangeService
+	channelService *ChannelService
 }
 
 func (s *LogService) Find(ctx context.Context, id string) (*models.Log, error) {
@@ -69,9 +70,12 @@ func (s *LogService) Create(ctx context.Context, title, description, channelName
 		return nil, err
 	}
 
-	// TODO: s.channelService.Ensure()
+	_, err := s.channelService.Ensure(ctx, channelName)
+	if err != nil {
+		return nil, err
+	}
 
-	log, err := s.logs.Insert(ctx, *log)
+	log, err = s.logs.Insert(ctx, *log)
 	if err != nil {
 		return nil, err
 	}
@@ -94,7 +98,10 @@ func (s *LogService) Import(ctx context.Context, importer models.LogImporter, da
 		eventName = channel.EventName
 	}
 
-	// TODO: Ensure channel
+	_, err := s.channelService.Ensure(ctx, channelName)
+	if err != nil {
+		return nil, err
+	}
 
 	date = date.In(tz)
 

services/services.go

@@ -11,6 +11,7 @@ type Bundle struct {
 	Characters *CharacterService
 	Changes    *ChangeService
 	Logs       *LogService
+	Channels   *ChannelService
 }
 
 // NewBundle creates a new bundle.
@@ -25,6 +26,11 @@ func NewBundle(db database.Database) *Bundle {
 		loader:        loaders.CharacterLoaderFromRepository(db.Characters()),
 		changeService: bundle.Changes,
 	}
+	bundle.Channels = &ChannelService{
+		channels:      db.Channels(),
+		loader:        loaders.ChannelLoaderFromRepository(db.Channels()),
+		changeService: bundle.Changes,
+	}
 	bundle.Logs = &LogService{
 		logs:          db.Logs(),
 		posts:         db.Posts(),