comic

type AppearanceType uint8

type AppearancesByYears struct {
	CharacterSlug CharacterSlug     `json:"slug"` // The unique identifier for the character.
	Aggregates    []YearlyAggregate `json:"aggregates"`
}

type AppearancesByYearsMapRepository interface {
	ListMap(slugs ...CharacterSlug) (map[CharacterSlug][]AppearancesByYears, error)
}

type AppearancesByYearsRepository interface {
	List(slugs CharacterSlug) (AppearancesByYears, error)
}

type AppearancesByYearsWriter interface {
	Set(apps AppearancesByYears) error
	Delete(slug CharacterSlug) (int64, error)
}

type AppearancesSyncer struct {
	// contains filtered or unexported fields
}

type AvgPerYearRank uint

type Character struct {
	ID                CharacterID   `json:"-"`
	Publisher         Publisher     `json:"publisher"`
	PublisherID       PublisherID   `pg:",fk:publisher_id" sql:",notnull,on_delete:CASCADE" json:"-"`
	Name              string        `sql:",notnull" json:"name"`
	OtherName         string        `json:"other_name"`
	Description       string        `json:"description"`
	Image             string        `json:"image"`
	Slug              CharacterSlug `sql:",notnull,unique:uix_character_slug" json:"slug"`
	VendorType        VendorType    `sql:",notnull,unique:uix_vendor_type_vendor_id" json:"-"`
	VendorID          string        `sql:",notnull,unique:uix_vendor_type_vendor_id" json:"-"`
	VendorImage       string        `json:"vendor_image"`
	VendorImageMd5    string        `sql:",type:varchar(32)," json:"-"`
	VendorURL         string        `json:"vendor_url"`
	VendorDescription string        `json:"vendor_description"`
	IsDisabled        bool          `json:"-" sql:",notnull"`
	CreatedAt         time.Time     `sql:",notnull,default:NOW()" json:"-"`
	UpdatedAt         time.Time     `sql:",notnull,default:NOW()" json:"-"`
	// contains filtered or unexported fields
}

type CharacterCriteria struct {
	IDs               []CharacterID
	Slugs             []CharacterSlug
	PublisherIDs      []PublisherID
	PublisherSlugs    []PublisherSlug
	FilterSources     bool         // Filter characters that only have sources. If false it returns characters regardless.
	FilterIssues      bool         // Filter characters that only have issues. If false it returns characters regardless.
	VendorTypes       []VendorType // Include characters that are disabled. By default it does not.
	IncludeIsDisabled bool
	VendorIds         []string
	Limit             int
	Offset            int
}

type CharacterID uint

type CharacterIssue struct {
	ID             CharacterIssueID
	Character      *Character     // Not eager-loaded. Could be nil.
	CharacterID    CharacterID    `pg:",fk:character_id" sql:",notnull,unique:uix_character_id_issue_id,on_delete:CASCADE"`
	Issue          *Issue         // Not eager-loaded. Could be nil.
	IssueID        IssueID        `pg:",fk:issue_id" sql:",notnull,unique:uix_character_id_issue_id,on_delete:CASCADE"`
	AppearanceType AppearanceType `sql:",notnull,type:bit(8),default:B'00000001'"`
	Importance     *Importance    `sql:",type:smallint"`
	CreatedAt      time.Time      `sql:",notnull,default:NOW()" json:"-"`
	UpdatedAt      time.Time      `sql:",notnull,default:NOW()" json:"-"`
	// contains filtered or unexported fields
}

type CharacterIssueID uint

type CharacterIssueRepository interface {
	CreateAll(cis []*CharacterIssue) error
	Create(ci *CharacterIssue) error
	FindOneBy(characterID CharacterID, issueID IssueID) (*CharacterIssue, error)
	InsertFast(issues []*CharacterIssue) error
	RemoveAllByCharacterID(id CharacterID) (int, error)
}

type CharacterRepository interface {
	Create(c *Character) error
	Update(c *Character) error
	FindBySlug(slug CharacterSlug, includeIsDisabled bool) (*Character, error)
	FindAll(cr CharacterCriteria) ([]*Character, error)
	UpdateAll(characters []*Character) error
	Remove(id CharacterID) error
	Total(cr CharacterCriteria) (int64, error)
}

type CharacterService struct {
	// contains filtered or unexported fields
}

type CharacterServicer interface {
	// Creates a character
	Create(character *Character) error
	// Character gets a character by its slug.
	Character(slug CharacterSlug) (*Character, error)
	// Updates a character.
	Update(character *Character) error
	// UpdateAll updates all characters
	UpdateAll(characters []*Character) error
	// CharactersWithSources gets all the enabled characters who have sources.
	CharactersWithSources(slug []CharacterSlug, limit, offset int) ([]*Character, error)
	// Characters gets all enabled characters by their slugs.
	Characters(slugs []CharacterSlug, limit, offset int) ([]*Character, error)
	// CharacterByVendor gets all the characters by the vendor. If `includeIsDisabled` is true, it will include disabled characters.
	CharacterByVendor(vendorID string, vendorType VendorType, includeIsDisabled bool) (*Character, error)
	// CharactersByPublisher list characters alphabetically. If `filterSources` is true, it will only list characters with sources.
	CharactersByPublisher(slugs []PublisherSlug, filterSources bool, limit, offset int) ([]*Character, error)
	// CreateSource creates a character source if it doesn't exist. If it exists, it returns the found source and an error.
	// And also modifies `source` to get the found values.
	CreateSource(source *CharacterSource) error
	// UpdateSource updates a character source
	UpdateSource(source *CharacterSource) error
	// MustNormalizeSources so that main vs alternate sources are categorized correctly and disables any unnecessary sources.
	// panics if there's an error.
	MustNormalizeSources(*Character)
	// Source gets a unique source by its character ID and vendor url.
	Source(id CharacterID, vendorURL string) (*CharacterSource, error)
	// Sources gets all the sources for a  character.
	Sources(id CharacterID, vendorType VendorType, isMain *bool) ([]*CharacterSource, error)
	// TotalSources gets the total sources for a character.
	TotalSources(id CharacterID) (int64, error)
	// CreateIssueP creates an issue for a character with the parameters.
	CreateIssueP(
		characterID CharacterID,
		issueID IssueID,
		appearanceType AppearanceType,
		importance *Importance) (*CharacterIssue, error)
	// CreateIssue creates an issue for a character.
	CreateIssue(issue *CharacterIssue) error
	// CreateIssues creates multiple issues for a character. // TODO: Autogenerated IDs not returned in struct!!
	CreateIssues(issues []*CharacterIssue) error
	// Issue gets a character issue by its character ID and issue ID
	Issue(characterID CharacterID, issueID IssueID) (*CharacterIssue, error)
	// RemoveIssues removes all the issues w/ the associated character ID.
	RemoveIssues(ids ...CharacterID) (int, error)
	// CreateSyncLogP creates a sync log for a character with the parameters.
	CreateSyncLogP(
		id CharacterID,
		status CharacterSyncLogStatus,
		syncType CharacterSyncLogType,
		syncedAt *time.Time) (*CharacterSyncLog, error)
	// CreateSyncLog creates a sync log.
	CreateSyncLog(syncLog *CharacterSyncLog) error
	// UpdateSyncLog updates a sync log
	UpdateSyncLog(syncLog *CharacterSyncLog) error
}

type CharacterSlug string

type CharacterSource struct {
	ID              CharacterSourceID `json:"id"`
	Character       *Character        // Pointer. Could be nil. Not eager-loaded.
	CharacterID     CharacterID       `pg:",fk:character_id" sql:",notnull,unique:uix_character_id_vendor_url,on_delete:CASCADE" json:"character_id"`
	VendorType      VendorType        `sql:",notnull,type:smallint" json:"type"`
	VendorURL       string            `sql:",notnull,unique:uix_character_id_vendor_url"`
	VendorName      string            `sql:",notnull"`
	VendorOtherName string
	IsDisabled      bool      `sql:",notnull"`
	IsMain          bool      `sql:",notnull"`
	CreatedAt       time.Time `sql:",default:NOW(),notnull" json:"-"`
	UpdatedAt       time.Time `sql:",notnull,default:NOW()" json:"-"`
	// contains filtered or unexported fields
}

type CharacterSourceCriteria struct {
	CharacterIDs []CharacterID
	VendorUrls   []string
	VendorType   VendorType
	// If IsMain is null, it will  return both.
	IsMain *bool
	// Include sources that are disabled. By default it does not include disabled sources.
	IncludeIsDisabled bool
	Limit             int
	Offset            int
}

type CharacterSourceID uint

type CharacterSourceRepository interface {
	Create(s *CharacterSource) error
	FindAll(criteria CharacterSourceCriteria) ([]*CharacterSource, error)
	Remove(id CharacterSourceID) error
	// Raw runs a raw query on the character sources.
	Raw(query string, params ...interface{}) error
	Update(s *CharacterSource) error
}

type CharacterStats struct {
	Category       CharacterStatsCategory `json:"category"`
	IssueCountRank uint                   `json:"issue_count_rank"`
	IssueCount     uint                   `json:"issue_count"`
	Average        float64                `json:"average_issues_per_year"`
	AverageRank    uint                   `json:"average_issues_per_year_rank"`
}

type CharacterStatsCategory string

type CharacterStatsSyncer interface {
	Sync(slug CharacterSlug) error
	SyncAll(characters []*Character) <-chan CharacterSyncResult
}

type CharacterSyncLog struct {
	ID          CharacterSyncLogID     `json:"id"`
	SyncType    CharacterSyncLogType   `sql:",notnull,type:smallint" json:"type"`
	SyncStatus  CharacterSyncLogStatus `sql:",notnull,type:smallint" json:"status"`
	Message     string
	SyncedAt    *time.Time  `json:"synced_at"`
	Character   *Character  // Not eager-loaded, could be nil.
	CharacterID CharacterID `pg:",fk:character_id" sql:",notnull,on_delete:CASCADE" json:"character_id"`
	CreatedAt   time.Time   `sql:",notnull,default:NOW()" json:"-"`
	UpdatedAt   time.Time   `sql:",notnull,default:NOW()" json:"-"`
	// contains filtered or unexported fields
}

type CharacterSyncLogID uint

type CharacterSyncLogRepository interface {
	Create(s *CharacterSyncLog) error
	FindAllByCharacterID(characterID CharacterID) ([]*CharacterSyncLog, error)
	Update(s *CharacterSyncLog) error
	FindByID(id CharacterSyncLogID) (*CharacterSyncLog, error)
	LastSyncs(id CharacterID) ([]*LastSync, error)
}

type CharacterSyncLogStatus int

type CharacterSyncLogType int

type CharacterSyncResult struct {
	Slug  CharacterSlug
	Error error
}

type CharacterThumbRepository interface {
	AllThumbnails(slugs ...CharacterSlug) (map[CharacterSlug]*CharacterThumbnails, error)
	Thumbnails(slug CharacterSlug) (*CharacterThumbnails, error)
}

type CharacterThumbService struct {
	// contains filtered or unexported fields
}

type CharacterThumbServicer interface {
	Upload(c *Character) (*CharacterThumbnails, error)
}

type CharacterThumbnails struct {
	Slug        CharacterSlug   `json:"slug"`
	Image       *ThumbnailSizes `json:"image"`
	VendorImage *ThumbnailSizes `json:"vendor_image"`
}

type ExpandedCharacter struct {
	*Character
	Thumbnails  *CharacterThumbnails `json:"thumbnails"`
	LastSyncs   []*LastSync          `json:"last_syncs"`
	Stats       []CharacterStats     `json:"stats"`
	Appearances AppearancesByYears   `json:"appearances"`
}

type ExpandedService struct {
	// contains filtered or unexported fields
}

type ExpandedServicer interface {
	Character(slug CharacterSlug) (*ExpandedCharacter, error)
}

type Format string

type Importance int

type Issue struct {
	ID                 IssueID
	PublicationDate    time.Time `sql:",notnull"`
	SaleDate           time.Time `sql:",notnull"` // @TODO: add an index.
	IsVariant          bool      `sql:",notnull"`
	MonthUncertain     bool      `sql:",notnull"`
	Format             Format    `sql:",notnull"`
	VendorPublisher    string    `sql:",notnull"`
	VendorSeriesName   string    `sql:",notnull"`
	VendorSeriesNumber string    `sql:",notnull"`
	// IsReprint means the issue is a full reprint with no original story. (So something like Classic X-Men 7 would not count).
	IsReprint  bool       `sql:"default:false,notnull"`
	VendorType VendorType `sql:",notnull,unique:uix_vendor_type_vendor_id,type:smallint"`
	VendorID   string     `sql:",notnull,unique:uix_vendor_type_vendor_id"`
	CreatedAt  time.Time  `sql:",notnull,default:NOW()" json:"-"`
	UpdatedAt  time.Time  `sql:",notnull,default:NOW()" json:"-"`
	// contains filtered or unexported fields
}

type IssueCountRank uint

type IssueCriteria struct {
	Ids        []IssueID
	VendorIds  []string
	VendorType VendorType
	Formats    []Format
	Limit      int
	Offset     int
}

type IssueID uint

type IssueRepository interface {
	Create(issue *Issue) error
	CreateAll(issues []*Issue) error
	Update(issue *Issue) error
	FindByVendorID(vendorID string) (*Issue, error)
	FindAll(c IssueCriteria) ([]*Issue, error)
}

type IssueService struct {
	// contains filtered or unexported fields
}

type IssueServicer interface {
	// Issues gets issues by their IDs.
	Issues(ids []IssueID, limit, offset int) ([]*Issue, error)
	// IssuesByVendor gets issues by their vendor IDs and vendor types.
	IssuesByVendor(vendorIds []string, vendorType VendorType, limit, offset int) ([]*Issue, error)
	// Creates an issue.
	Create(issue *Issue) error
	// CreateP ceates an issue from parameters.
	CreateP(
		vendorID, vendorPublisher, vendorSeriesName, vendorSeriesNumber string,
		pubDate, saleDate time.Time,
		isVariant, isMonthUncertain, isReprint bool,
		format Format) error
}

type LastSync struct {
	CharacterID CharacterID `json:"-"`
	SyncedAt    time.Time   `json:"synced_at"`
	NumIssues   int         `json:"num_issues"`
}

type MaterializedView string

type ORM interface {
	Model(model ...interface{}) *orm.Query
	Update(model interface{}) error
	Query(model, query interface{}, params ...interface{}) (res orm.Result, err error)
	Exec(query interface{}, params ...interface{}) (res orm.Result, err error)
	Insert(model ...interface{}) error
	QueryOne(model, query interface{}, params ...interface{}) (orm.Result, error)
	RunInTransaction(fn func(tx *pg.Tx) error) error
}

type PGAppearancesByYearsRepository struct {
	// contains filtered or unexported fields
}

type PGCharacterIssueRepository struct {
	// contains filtered or unexported fields
}

type PGCharacterRepository struct {
	// contains filtered or unexported fields
}

type PGCharacterSourceRepository struct {
	// contains filtered or unexported fields
}

type PGCharacterSyncLogRepository struct {
	// contains filtered or unexported fields
}

type PGIssueRepository struct {
	// contains filtered or unexported fields
}

type PGPopularRepository struct {
	// contains filtered or unexported fields
}

type PGPublisherRepository struct {
	// contains filtered or unexported fields
}

type PGStatsRepository struct {
	// contains filtered or unexported fields
}

type PopularCriteria struct {
	AppearanceType AppearanceType
	SortBy         PopularSortCriteria
	Limit          int
	Offset         int
}

type PopularRefresher interface {
	Refresh(view MaterializedView) error
	RefreshAll() error
}

type PopularRepository interface {
	All(cr PopularCriteria) ([]*RankedCharacter, error)
	DC(cr PopularCriteria) ([]*RankedCharacter, error)
	Marvel(cr PopularCriteria) ([]*RankedCharacter, error)
	FindOneByDC(id CharacterID) (*RankedCharacter, error)
	FindOneByMarvel(id CharacterID) (*RankedCharacter, error)
	FindOneByAll(id CharacterID) (*RankedCharacter, error)
	MarvelTrending(limit, offset int) ([]*RankedCharacter, error)
	DCTrending(limit, offset int) ([]*RankedCharacter, error)
}

type PopularSortCriteria string

type Publisher struct {
	ID        PublisherID   `json:"-"`
	Name      string        `json:"name" sql:",notnull"`
	Slug      PublisherSlug `json:"slug" sql:",notnull,unique:uix_publisher_slug"`
	CreatedAt time.Time     `json:"-" sql:",notnull,default:NOW()"`
	UpdatedAt time.Time     `sql:",notnull,default:NOW()" json:"-"`
	// contains filtered or unexported fields
}

type PublisherID uint

type PublisherRepository interface {
	FindBySlug(slug PublisherSlug) (*Publisher, error)
}

type PublisherService struct {
	// contains filtered or unexported fields
}

type PublisherServicer interface {
	// Publisher gets a publisher by its slug.
	Publisher(slug PublisherSlug) (*Publisher, error)
}

type PublisherSlug string

type RankedCharacter struct {
	ID                CharacterID          `json:"-"`
	Publisher         Publisher            `json:"publisher"`
	PublisherID       PublisherID          `json:"-"`
	Name              string               `json:"name"`
	OtherName         string               `json:"other_name"`
	Description       string               `json:"description"`
	Image             string               `json:"image"`
	Slug              CharacterSlug        `json:"slug"`
	VendorImage       string               `json:"vendor_image"`
	VendorURL         string               `json:"vendor_url"`
	VendorDescription string               `json:"vendor_description"`
	Thumbnails        *CharacterThumbnails `json:"thumbnails"`
	Stats             CharacterStats       `json:"stats"`
}

type RankedService struct {
	// contains filtered or unexported fields
}

type RankedServicer interface {
	AllPopular(cr PopularCriteria) ([]*RankedCharacter, error)
	DCPopular(cr PopularCriteria) ([]*RankedCharacter, error)
	MarvelPopular(cr PopularCriteria) ([]*RankedCharacter, error)
	MarvelTrending(limit, offset int) ([]*RankedCharacter, error)
	DCTrending(limit, offset int) ([]*RankedCharacter, error)
}

type RedisAppearancesByYearsRepository struct {
	// contains filtered or unexported fields
}

type RedisCharacterStatsSyncer struct {
	// contains filtered or unexported fields
}

type RedisCharacterThumbRepository struct {
	// contains filtered or unexported fields
}

type RedisClient interface {
	Get(key string) *redis.StringCmd
	MGet(keys ...string) *redis.SliceCmd
	Set(key string, value interface{}, expiration time.Duration) *redis.StatusCmd
	HMSet(key string, fields map[string]interface{}) *redis.StatusCmd
	HGetAll(key string) *redis.StringStringMapCmd
	Del(keys ...string) *redis.IntCmd
}

type RedisHmSetter interface {
	HMSet(key string, fields map[string]interface{}) *redis.StatusCmd
}

type RedisYearlyAggregateDeserializer struct {
}

type RedisYearlyAggregateSerializer struct {
}

type Stats struct {
	TotalCharacters  int `json:"total_characters"`
	TotalAppearances int `json:"total_appearances"`
	MinYear          int `json:"min_year"`
	MaxYear          int `json:"max_year"`
	TotalIssues      int `json:"total_issues"`
}

type StatsRepository interface {
	Stats() (Stats, error)
}

type Syncer interface {
	// Syncs appearances from postgres to redis. Returns the number of issues synced and an error if any.
	Sync(slug CharacterSlug) (int, error)
}

type ThumbnailSizes struct {
	Small  string `json:"small"`
	Medium string `json:"medium"`
	Large  string `json:"large"`
}

type Transactional interface {
	RunInTransaction(fn func(tx *pg.Tx) error) error
}

type TrendingCriteria struct {
	PublisherID PublisherID
	Limit       int
	Offset      int
}

type VendorType int

type YearlyAggregate struct {
	Main      int `json:"main"`
	Alternate int `json:"alternate"`
	Year      int `json:"year"`
}

type YearlyAggregateDeserializer interface {
	Deserialize(val string) []YearlyAggregate
}

type YearlyAggregateSerializer interface {
	Serialize(aggregates []YearlyAggregate) string
}