importer

Documentation

Index

• Variables
• type ActiveImport
• type ImportErrors
  • func (e ImportErrors) Error() string
  • func (e ImportErrors) IsNil() bool
  • func (e ImportErrors) OrNil() error
• type ImportItemsError
  • func (e ImportItemsError) Error() string
• type Importer
• type Info
• type Item
• type Params
• type Result
  • func New(p Params) Result

Variables

var (
	ErrImportClosed = errors.New("import closed")
)

Types

type ActiveImport

type ActiveImport interface {
	Import(items ...Item) error
	Drain()
	Closed() bool
	Close() error
	Err() error
}

type ImportErrors

type ImportErrors []ImportItemsError

func (ImportErrors) Error

func (e ImportErrors) Error() string

func (ImportErrors) IsNil

func (e ImportErrors) IsNil() bool

func (ImportErrors) OrNil

func (e ImportErrors) OrNil() error

type ImportItemsError

type ImportItemsError struct {
	Items []Item
	Err   error
}

func (ImportItemsError) Error

func (e ImportItemsError) Error() string

type Importer

type Importer interface {
	New(ctx context.Context, info Info) ActiveImport
}

type Info

type Info struct {
	ID string
}

type Item

type Item struct {
	Source          string
	InfoHash        protocol.ID
	Name            string
	Size            uint
	Private         bool
	ContentType     model.NullContentType
	ContentSource   model.NullString
	ContentID       model.NullString
	Title           model.NullString
	ReleaseDate     model.Date
	ReleaseYear     model.Year
	Episodes        model.Episodes
	VideoResolution model.NullVideoResolution
	VideoSource     model.NullVideoSource
	VideoCodec      model.NullVideoCodec
	Video3D         model.NullVideo3D
	VideoModifier   model.NullVideoModifier
	ReleaseGroup    model.NullString
	PublishedAt     time.Time
}

type Params

type Params struct {
	fx.In
	Dao lazy.Lazy[*dao.Query]
}

type Result

type Result struct {
	fx.Out
	Importer lazy.Lazy[Importer]
}

func New

func New(p Params) Result