backends

Documentation

Overview

Copyright © 2023 Philipp Wolfer <phw@uploadedlobster.com>

This file is part of Scotty.

Scotty is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

Scotty is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with Scotty. If not, see <https://www.gnu.org/licenses/>.

Index

• func Authenticate(service string, backend models.Backend, db storage.Database, ...) (bool, error)
• func BackendByName(backendName string) (models.Backend, error)
• func BuildRedirectURL(config *viper.Viper, backend string) (*url.URL, error)
• func ImplementsInterface[T interface{}](backend *models.Backend) (bool, string)
• func ResolveBackend[T interface{}](config config.ServiceConfig) (T, error)
• type BackendInfo
  • func (b BackendInfo) String() string
• type BackendList
  • func GetBackends() BackendList
  • func (l BackendList) Len() int
  • func (l BackendList) Less(i, j int) bool
  • func (l BackendList) Swap(i, j int)
• type Capability
• type ExportProcessor
• type ImportProcessor
• type ListensExportProcessor
  • func (p ListensExportProcessor) ExportBackend() models.Backend
  • func (p ListensExportProcessor) Process(oldestTimestamp time.Time, results chan models.ListensResult, ...)
• type ListensImportProcessor
  • func (p ListensImportProcessor) Import(export models.ListensResult, result models.ImportResult, ...) (models.ImportResult, error)
  • func (p ListensImportProcessor) ImportBackend() models.ImportBackend
  • func (p ListensImportProcessor) Process(results chan models.ListensResult, out chan models.ImportResult, ...)
• type LovesExportProcessor
  • func (p LovesExportProcessor) ExportBackend() models.Backend
  • func (p LovesExportProcessor) Process(oldestTimestamp time.Time, results chan models.LovesResult, ...)
• type LovesImportProcessor
  • func (p LovesImportProcessor) Import(export models.LovesResult, result models.ImportResult, ...) (models.ImportResult, error)
  • func (p LovesImportProcessor) ImportBackend() models.ImportBackend
  • func (p LovesImportProcessor) Process(results chan models.LovesResult, out chan models.ImportResult, ...)

Functions

func Authenticate

func Authenticate(service string, backend models.Backend, db storage.Database, config *viper.Viper) (bool, error)

func BackendByName

func BackendByName(backendName string) (models.Backend, error)

func BuildRedirectURL

func BuildRedirectURL(config *viper.Viper, backend string) (*url.URL, error)

func ImplementsInterface

func ImplementsInterface[T interface{}](backend *models.Backend) (bool, string)

func ResolveBackend

func ResolveBackend[T interface{}](config config.ServiceConfig) (T, error)

Types

type BackendInfo

type BackendInfo struct {
	Name               string
	ExportCapabilities []Capability
	ImportCapabilities []Capability
}

func (BackendInfo) String

func (b BackendInfo) String() string

type BackendList

type BackendList []BackendInfo

func GetBackends

func GetBackends() BackendList

func (BackendList) Len

func (l BackendList) Len() int

func (BackendList) Less

func (l BackendList) Less(i, j int) bool

func (BackendList) Swap

func (l BackendList) Swap(i, j int)

type Capability

type Capability = string

type ExportProcessor

type ExportProcessor[T models.ListensResult | models.LovesResult] interface {
	ExportBackend() models.Backend
	Process(oldestTimestamp time.Time, results chan T, progress chan models.Progress)
}

type ImportProcessor

type ImportProcessor[T models.ListensResult | models.LovesResult] interface {
	ImportBackend() models.ImportBackend
	Process(results chan T, out chan models.ImportResult, progress chan models.Progress)
	Import(export T, result models.ImportResult, out chan models.ImportResult, progress chan models.Progress) (models.ImportResult, error)
}

type ListensExportProcessor

type ListensExportProcessor struct {
	Backend models.ListensExport
}

func (ListensExportProcessor) ExportBackend

func (p ListensExportProcessor) ExportBackend() models.Backend

func (ListensExportProcessor) Process

func (p ListensExportProcessor) Process(oldestTimestamp time.Time, results chan models.ListensResult, progress chan models.Progress)

type ListensImportProcessor

type ListensImportProcessor struct {
	Backend models.ListensImport
}

func (ListensImportProcessor) Import

func (p ListensImportProcessor) Import(export models.ListensResult, result models.ImportResult, out chan models.ImportResult, progress chan models.Progress) (models.ImportResult, error)

func (ListensImportProcessor) ImportBackend

func (p ListensImportProcessor) ImportBackend() models.ImportBackend

func (ListensImportProcessor) Process

func (p ListensImportProcessor) Process(results chan models.ListensResult, out chan models.ImportResult, progress chan models.Progress)

type LovesExportProcessor

type LovesExportProcessor struct {
	Backend models.LovesExport
}

func (LovesExportProcessor) ExportBackend

func (p LovesExportProcessor) ExportBackend() models.Backend

func (LovesExportProcessor) Process

func (p LovesExportProcessor) Process(oldestTimestamp time.Time, results chan models.LovesResult, progress chan models.Progress)

type LovesImportProcessor

type LovesImportProcessor struct {
	Backend models.LovesImport
}

func (LovesImportProcessor) Import

func (p LovesImportProcessor) Import(export models.LovesResult, result models.ImportResult, out chan models.ImportResult, progress chan models.Progress) (models.ImportResult, error)

func (LovesImportProcessor) ImportBackend

func (p LovesImportProcessor) ImportBackend() models.ImportBackend

func (LovesImportProcessor) Process

func (p LovesImportProcessor) Process(results chan models.LovesResult, out chan models.ImportResult, progress chan models.Progress)