feat: add backend

internal/indexer/service.go

@@ -0,0 +1,252 @@
+package indexer
+
+import (
+	"fmt"
+	"io/fs"
+	"strings"
+
+	"gopkg.in/yaml.v2"
+
+	"github.com/rs/zerolog/log"
+
+	"github.com/autobrr/autobrr/internal/domain"
+)
+
+type Service interface {
+	Store(indexer domain.Indexer) (*domain.Indexer, error)
+	Update(indexer domain.Indexer) (*domain.Indexer, error)
+	Delete(id int) error
+	FindByFilterID(id int) ([]domain.Indexer, error)
+	List() ([]domain.Indexer, error)
+	GetAll() ([]*domain.IndexerDefinition, error)
+	GetTemplates() ([]domain.IndexerDefinition, error)
+	LoadIndexerDefinitions() error
+	GetIndexerByAnnounce(name string) *domain.IndexerDefinition
+	Start() error
+}
+
+type service struct {
+	repo                domain.IndexerRepo
+	indexerDefinitions  map[string]domain.IndexerDefinition
+	indexerInstances    map[string]domain.IndexerDefinition
+	mapIndexerIRCToName map[string]string
+}
+
+func NewService(repo domain.IndexerRepo) Service {
+	return &service{
+		repo:                repo,
+		indexerDefinitions:  make(map[string]domain.IndexerDefinition),
+		indexerInstances:    make(map[string]domain.IndexerDefinition),
+		mapIndexerIRCToName: make(map[string]string),
+	}
+}
+
+func (s *service) Store(indexer domain.Indexer) (*domain.Indexer, error) {
+	i, err := s.repo.Store(indexer)
+	if err != nil {
+		return nil, err
+	}
+
+	return i, nil
+}
+
+func (s *service) Update(indexer domain.Indexer) (*domain.Indexer, error) {
+	i, err := s.repo.Update(indexer)
+	if err != nil {
+		return nil, err
+	}
+
+	return i, nil
+}
+
+func (s *service) Delete(id int) error {
+	if err := s.repo.Delete(id); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *service) FindByFilterID(id int) ([]domain.Indexer, error) {
+	filters, err := s.repo.FindByFilterID(id)
+	if err != nil {
+		return nil, err
+	}
+
+	return filters, nil
+}
+
+func (s *service) List() ([]domain.Indexer, error) {
+	i, err := s.repo.List()
+	if err != nil {
+		return nil, err
+	}
+
+	return i, nil
+}
+
+func (s *service) GetAll() ([]*domain.IndexerDefinition, error) {
+	indexers, err := s.repo.List()
+	if err != nil {
+		return nil, err
+	}
+
+	var res = make([]*domain.IndexerDefinition, 0)
+
+	for _, indexer := range indexers {
+		in := s.getDefinitionByName(indexer.Identifier)
+		if in == nil {
+			// if no indexerDefinition found, continue
+			continue
+		}
+
+		temp := domain.IndexerDefinition{
+			ID:          indexer.ID,
+			Name:        in.Name,
+			Identifier:  in.Identifier,
+			Enabled:     indexer.Enabled,
+			Description: in.Description,
+			Language:    in.Language,
+			Privacy:     in.Privacy,
+			Protocol:    in.Protocol,
+			URLS:        in.URLS,
+			Settings:    nil,
+			SettingsMap: make(map[string]string),
+			IRC:         in.IRC,
+			Parse:       in.Parse,
+		}
+
+		// map settings
+		// add value to settings objects
+		for _, setting := range in.Settings {
+			if v, ok := indexer.Settings[setting.Name]; ok {
+				setting.Value = v
+
+				temp.SettingsMap[setting.Name] = v
+			}
+
+			temp.Settings = append(temp.Settings, setting)
+		}
+
+		res = append(res, &temp)
+	}
+
+	return res, nil
+}
+
+func (s *service) GetTemplates() ([]domain.IndexerDefinition, error) {
+
+	definitions := s.indexerDefinitions
+
+	var ret []domain.IndexerDefinition
+	for _, definition := range definitions {
+		ret = append(ret, definition)
+	}
+
+	return ret, nil
+}
+
+func (s *service) Start() error {
+	err := s.LoadIndexerDefinitions()
+	if err != nil {
+		return err
+	}
+
+	indexers, err := s.GetAll()
+	if err != nil {
+		return err
+	}
+
+	for _, indexer := range indexers {
+		if !indexer.Enabled {
+			continue
+		}
+
+		s.indexerInstances[indexer.Identifier] = *indexer
+
+		// map irc stuff to indexer.name
+		if indexer.IRC != nil {
+			server := indexer.IRC.Server
+
+			for _, channel := range indexer.IRC.Channels {
+				for _, announcer := range indexer.IRC.Announcers {
+					val := fmt.Sprintf("%v:%v:%v", server, channel, announcer)
+					s.mapIndexerIRCToName[val] = indexer.Identifier
+				}
+			}
+		}
+	}
+
+	return nil
+}
+
+// LoadIndexerDefinitions load definitions from golang embed fs
+func (s *service) LoadIndexerDefinitions() error {
+
+	entries, err := fs.ReadDir(Definitions, "definitions")
+	if err != nil {
+		log.Fatal().Msgf("failed reading directory: %s", err)
+	}
+
+	if len(entries) == 0 {
+		log.Fatal().Msgf("failed reading directory: %s", err)
+		return err
+	}
+
+	for _, f := range entries {
+		filePath := "definitions/" + f.Name()
+
+		if strings.Contains(f.Name(), ".yaml") {
+			log.Debug().Msgf("parsing: %v", filePath)
+
+			var d domain.IndexerDefinition
+
+			data, err := fs.ReadFile(Definitions, filePath)
+			if err != nil {
+				log.Debug().Err(err).Msgf("failed reading file: %v", filePath)
+				return err
+			}
+
+			err = yaml.Unmarshal(data, &d)
+			if err != nil {
+				log.Error().Err(err).Msgf("failed unmarshal file: %v", filePath)
+				return err
+			}
+
+			s.indexerDefinitions[d.Identifier] = d
+		}
+	}
+
+	return nil
+}
+
+func (s *service) GetIndexerByAnnounce(name string) *domain.IndexerDefinition {
+
+	if identifier, idOk := s.mapIndexerIRCToName[name]; idOk {
+		if indexer, ok := s.indexerInstances[identifier]; ok {
+			return &indexer
+		}
+	}
+
+	return nil
+}
+
+func (s *service) getDefinitionByName(name string) *domain.IndexerDefinition {
+
+	if v, ok := s.indexerDefinitions[name]; ok {
+		return &v
+	}
+
+	return nil
+}
+
+func (s *service) getDefinitionForAnnounce(name string) *domain.IndexerDefinition {
+
+	// map[network:channel:announcer] = indexer01
+
+	if v, ok := s.indexerDefinitions[name]; ok {
+		return &v
+	}
+
+	return nil
+}