mirror/mxpv-podsync
1
0
Fork 0
mirror of https://github.com/mxpv/podsync.git synced 2024-05-11 05:55:04 +00:00
Code Issues Releases Activity

fix warnning: Variable 'feed' collides with imported package name

Browse Source
This commit is contained in:
ligang945
2024-04-09 15:16:21 +08:00
committed by Maksym Pavlenko
parent 0ee0c6e853
commit c3d2ba3efe
7 changed files with 81 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
cmd/podsync/config.go
View File

@ -155,29 +155,29 @@ func (c *Config) applyDefaults(configPath string) {
c.Database.Dir = filepath.Join(filepath.Dir(configPath), "db")
}
for _, feed := range c.Feeds {
if feed.UpdatePeriod == 0 {
feed.UpdatePeriod = model.DefaultUpdatePeriod
for _, _feed := range c.Feeds {
if _feed.UpdatePeriod == 0 {
_feed.UpdatePeriod = model.DefaultUpdatePeriod
}
if feed.Quality == "" {
feed.Quality = model.DefaultQuality
if _feed.Quality == "" {
_feed.Quality = model.DefaultQuality
}
if feed.Custom.CoverArtQuality == "" {
feed.Custom.CoverArtQuality = model.DefaultQuality
if _feed.Custom.CoverArtQuality == "" {
_feed.Custom.CoverArtQuality = model.DefaultQuality
}
if feed.Format == "" {
feed.Format = model.DefaultFormat
if _feed.Format == "" {
_feed.Format = model.DefaultFormat
}
if feed.PageSize == 0 {
feed.PageSize = model.DefaultPageSize
if _feed.PageSize == 0 {
_feed.PageSize = model.DefaultPageSize
}
if feed.PlaylistSort == "" {
feed.PlaylistSort = model.SortingAsc
if _feed.PlaylistSort == "" {
_feed.PlaylistSort = model.SortingAsc
}
}
}

36
cmd/podsync/main.go
View File

@ -154,9 +154,9 @@ func main() {
// In Headless mode, do one round of feed updates and quit
if opts.Headless {
for _, feed := range cfg.Feeds {
if err := manager.Update(ctx, feed); err != nil {
log.WithError(err).Errorf("failed to update feed: %s", feed.URL)
for _, _feed := range cfg.Feeds {
if err := manager.Update(ctx, _feed); err != nil {
log.WithError(err).Errorf("failed to update feed: %s", _feed.URL)
}
}
return
@ -182,11 +182,11 @@ func main() {
group.Go(func() error {
for {
select {
case feed := <-updates:
if err := manager.Update(ctx, feed); err != nil {
log.WithError(err).Errorf("failed to update feed: %s", feed.URL)
case _feed := <-updates:
if err := manager.Update(ctx, _feed); err != nil {
log.WithError(err).Errorf("failed to update feed: %s", _feed.URL)
} else {
log.Infof("next update of %s: %s", feed.ID, c.Entry(m[feed.ID]).Next)
log.Infof("next update of %s: %s", _feed.ID, c.Entry(m[_feed.ID]).Next)
}
case <-ctx.Done():
return ctx.Err()
@ -198,22 +198,22 @@ func main() {
group.Go(func() error {
var cronID cron.EntryID
for _, feed := range cfg.Feeds {
if feed.CronSchedule == "" {
feed.CronSchedule = fmt.Sprintf("@every %s", feed.UpdatePeriod.String())
for _, _feed := range cfg.Feeds {
if _feed.CronSchedule == "" {
_feed.CronSchedule = fmt.Sprintf("@every %s", _feed.UpdatePeriod.String())
}
_feed := feed
if cronID, err = c.AddFunc(_feed.CronSchedule, func() {
log.Debugf("adding %q to update queue", _feed.ID)
updates <- _feed
cronFeed := _feed
if cronID, err = c.AddFunc(cronFeed.CronSchedule, func() {
log.Debugf("adding %q to update queue", cronFeed.ID)
updates <- cronFeed
}); err != nil {
log.WithError(err).Fatalf("can't create cron task for feed: %s", _feed.ID)
log.WithError(err).Fatalf("can't create cron task for feed: %s", cronFeed.ID)
}
m[_feed.ID] = cronID
log.Debugf("-> %s (update '%s')", _feed.ID, _feed.CronSchedule)
m[cronFeed.ID] = cronID
log.Debugf("-> %s (update '%s')", cronFeed.ID, cronFeed.CronSchedule)
// Perform initial update after CLI restart
updates <- _feed
updates <- cronFeed
}
c.Start()

22
pkg/builder/soundcloud.go
View File

@ -22,7 +22,7 @@ func (s *SoundCloudBuilder) Build(_ctx context.Context, cfg *feed.Config) (*mode
return nil, err
}
feed := &model.Feed{
_feed := &model.Feed{
ItemID: info.ItemID,
Provider: info.Provider,
LinkType: info.LinkType,
@ -39,16 +39,16 @@ func (s *SoundCloudBuilder) Build(_ctx context.Context, cfg *feed.Config) (*mode
return nil, err
}
feed.Title = scplaylist.Title
feed.Description = scplaylist.Description
feed.ItemURL = cfg.URL
_feed.Title = scplaylist.Title
_feed.Description = scplaylist.Description
_feed.ItemURL = cfg.URL
date, err := time.Parse(time.RFC3339, scplaylist.CreatedAt)
if err == nil {
feed.PubDate = date
_feed.PubDate = date
}
feed.Author = scplaylist.User.Username
feed.CoverArt = scplaylist.ArtworkURL
_feed.Author = scplaylist.User.Username
_feed.CoverArt = scplaylist.ArtworkURL
var added = 0
for _, track := range scplaylist.Tracks {
@ -60,7 +60,7 @@ func (s *SoundCloudBuilder) Build(_ctx context.Context, cfg *feed.Config) (*mode
trackSize = track.DurationMS * 15 // very rough estimate
)
feed.Episodes = append(feed.Episodes, &model.Episode{
_feed.Episodes = append(_feed.Episodes, &model.Episode{
ID: videoID,
Title: track.Title,
Description: track.Description,
@ -74,12 +74,12 @@ func (s *SoundCloudBuilder) Build(_ctx context.Context, cfg *feed.Config) (*mode
added++
if added >= feed.PageSize {
return feed, nil
if added >= _feed.PageSize {
return _feed, nil
}
}
return feed, nil
return _feed, nil
}
}

14
pkg/builder/soundcloud_test.go
View File

@ -19,17 +19,17 @@ func TestSoundCloud_BuildFeed(t *testing.T) {
for _, addr := range urls {
t.Run(addr, func(t *testing.T) {
feed, err := builder.Build(testCtx, &feed.Config{URL: addr})
_feed, err := builder.Build(testCtx, &feed.Config{URL: addr})
require.NoError(t, err)
assert.NotEmpty(t, feed.Title)
assert.NotEmpty(t, feed.Description)
assert.NotEmpty(t, feed.Author)
assert.NotEmpty(t, feed.ItemURL)
assert.NotEmpty(t, _feed.Title)
assert.NotEmpty(t, _feed.Description)
assert.NotEmpty(t, _feed.Author)
assert.NotEmpty(t, _feed.ItemURL)
assert.NotZero(t, len(feed.Episodes))
assert.NotZero(t, len(_feed.Episodes))
for _, item := range feed.Episodes {
for _, item := range _feed.Episodes {
assert.NotEmpty(t, item.Title)
assert.NotEmpty(t, item.VideoURL)
assert.NotZero(t, item.Duration)

20
pkg/builder/vimeo.go
View File

@ -164,7 +164,7 @@ func (v *VimeoBuilder) Build(ctx context.Context, cfg *feed.Config) (*model.Feed
return nil, err
}
feed := &model.Feed{
_feed := &model.Feed{
ItemID: info.ItemID,
Provider: info.Provider,
LinkType: info.LinkType,
@ -175,39 +175,39 @@ func (v *VimeoBuilder) Build(ctx context.Context, cfg *feed.Config) (*model.Feed
}
if info.LinkType == model.TypeChannel {
if err := v.queryChannel(feed); err != nil {
if err := v.queryChannel(_feed); err != nil {
return nil, err
}
if err := v.queryVideos(v.client.Channels.ListVideo, feed); err != nil {
if err := v.queryVideos(v.client.Channels.ListVideo, _feed); err != nil {
return nil, err
}
return feed, nil
return _feed, nil
}
if info.LinkType == model.TypeGroup {
if err := v.queryGroup(feed); err != nil {
if err := v.queryGroup(_feed); err != nil {
return nil, err
}
if err := v.queryVideos(v.client.Groups.ListVideo, feed); err != nil {
if err := v.queryVideos(v.client.Groups.ListVideo, _feed); err != nil {
return nil, err
}
return feed, nil
return _feed, nil
}
if info.LinkType == model.TypeUser {
if err := v.queryUser(feed); err != nil {
if err := v.queryUser(_feed); err != nil {
return nil, err
}
if err := v.queryVideos(v.client.Users.ListVideo, feed); err != nil {
if err := v.queryVideos(v.client.Users.ListVideo, _feed); err != nil {
return nil, err
}
return feed, nil
return _feed, nil
}
return nil, errors.New("unsupported feed type")

22
pkg/builder/youtube.go
View File

@ -410,7 +410,7 @@ func (yt *YouTubeBuilder) Build(ctx context.Context, cfg *feed.Config) (*model.F
return nil, err
}
feed := &model.Feed{
_feed := &model.Feed{
ItemID: info.ItemID,
Provider: info.Provider,
LinkType: info.LinkType,
@ -423,32 +423,32 @@ func (yt *YouTubeBuilder) Build(ctx context.Context, cfg *feed.Config) (*model.F
UpdatedAt: time.Now().UTC(),
}
if feed.PageSize == 0 {
feed.PageSize = maxYoutubeResults
if _feed.PageSize == 0 {
_feed.PageSize = maxYoutubeResults
}
// Query general information about feed (title, description, lang, etc)
if err := yt.queryFeed(ctx, feed, &info); err != nil {
if err := yt.queryFeed(ctx, _feed, &info); err != nil {
return nil, err
}
if err := yt.queryItems(ctx, feed); err != nil {
if err := yt.queryItems(ctx, _feed); err != nil {
return nil, err
}
// YT API client gets 50 episodes per query.
// Round up to page size.
if len(feed.Episodes) > feed.PageSize {
feed.Episodes = feed.Episodes[:feed.PageSize]
if len(_feed.Episodes) > _feed.PageSize {
_feed.Episodes = _feed.Episodes[:_feed.PageSize]
}
sort.Slice(feed.Episodes, func(i, j int) bool {
item1, _ := strconv.Atoi(feed.Episodes[i].Order)
item2, _ := strconv.Atoi(feed.Episodes[j].Order)
sort.Slice(_feed.Episodes, func(i, j int) bool {
item1, _ := strconv.Atoi(_feed.Episodes[i].Order)
item2, _ := strconv.Atoi(_feed.Episodes[j].Order)
return item1 < item2
})
return feed, nil
return _feed, nil
}
func NewYouTubeBuilder(key string) (*YouTubeBuilder, error) {

22
pkg/builder/youtube_test.go
View File

@ -52,17 +52,17 @@ func TestYT_BuildFeed(t *testing.T) {
for _, addr := range urls {
t.Run(addr, func(t *testing.T) {
feed, err := builder.Build(testCtx, &feed.Config{URL: addr})
_feed, err := builder.Build(testCtx, &feed.Config{URL: addr})
require.NoError(t, err)
assert.NotEmpty(t, feed.Title)
assert.NotEmpty(t, feed.Description)
assert.NotEmpty(t, feed.Author)
assert.NotEmpty(t, feed.ItemURL)
assert.NotEmpty(t, _feed.Title)
assert.NotEmpty(t, _feed.Description)
assert.NotEmpty(t, _feed.Author)
assert.NotEmpty(t, _feed.ItemURL)
assert.NotZero(t, len(feed.Episodes))
assert.NotZero(t, len(_feed.Episodes))
for _, item := range feed.Episodes {
for _, item := range _feed.Episodes {
assert.NotEmpty(t, item.Title)
assert.NotEmpty(t, item.VideoURL)
assert.NotZero(t, item.Duration)
@ -91,10 +91,10 @@ func TestYT_GetVideoCount(t *testing.T) {
{Provider: model.ProviderYoutube, LinkType: model.TypePlaylist, ItemID: "PLUVl5pafUrBydT_gsCjRGeCy0hFHloec8"},
}
for _, f := range feeds {
feed := f
t.Run(f.ItemID, func(t *testing.T) {
count, err := builder.GetVideoCount(testCtx, feed)
for _, _feed := range feeds {
feedCopy := _feed
t.Run(_feed.ItemID, func(t *testing.T) {
count, err := builder.GetVideoCount(testCtx, feedCopy)
assert.NoError(t, err)
assert.NotZero(t, count)
})