mirrors/navidrome
1
0
Fork 0
mirror of https://github.com/navidrome/navidrome.git synced 2025-04-03 20:47:35 +03:00
Code Issues Projects Releases Packages Wiki Activity

Removed unused code

Browse source
This commit is contained in:
Deluan 2021-10-22 18:55:10 -04:00 • committed by Deluan Quintão
parent 806b13cf42
commit c73f64ee3a
4 changed files with 2 additions and 210 deletions
Download patch file Download diff file Expand all files Collapse all files

1
core/playlists_test.go
View file

@ -6,7 +6,6 @@ import (
"github.com/navidrome/navidrome/model"
"github.com/navidrome/navidrome/tests"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)

4
model/criteria/criteria.go
View file

@ -35,9 +35,9 @@ func (c Criteria) MarshalJSON() ([]byte, error) {
aux := struct {
All []Expression `json:"all,omitempty"`
Any []Expression `json:"any,omitempty"`
Sort string `json:"sort"`
Sort string `json:"sort,omitempty"`
Order string `json:"order,omitempty"`
Limit int `json:"limit"`
Limit int `json:"limit,omitempty"`
Offset int `json:"offset,omitempty"`
}{
Sort: c.Sort,

106
model/smartplaylist.go
View file

@ -1,106 +0,0 @@
package model
import (
"encoding/json"
"errors"
)
type SmartPlaylist struct {
RuleGroup
Order string `json:"order,omitempty"`
Limit int `json:"limit,omitempty"`
}
type RuleGroup struct {
Combinator string `json:"combinator"`
Rules Rules `json:"rules"`
}
type Rules []IRule
type IRule interface {
Fields() []string
}
type Rule struct {
Field string `json:"field"`
Operator string `json:"operator"`
Value interface{} `json:"value,omitempty"`
}
func (r Rule) Fields() []string {
return []string{r.Field}
}
func (rg RuleGroup) Fields() []string {
var result []string
unique := map[string]struct{}{}
for _, r := range rg.Rules {
for _, f := range r.Fields() {
if _, added := unique[f]; !added {
result = append(result, f)
unique[f] = struct{}{}
}
}
}
return result
}
func (rs *Rules) UnmarshalJSON(data []byte) error {
var rawRules []json.RawMessage
if err := json.Unmarshal(data, &rawRules); err != nil {
return err
}
rules := make(Rules, len(rawRules))
for i, rawRule := range rawRules {
var r Rule
if err := json.Unmarshal(rawRule, &r); err == nil && r.Field != "" {
rules[i] = r
continue
}
var g RuleGroup
if err := json.Unmarshal(rawRule, &g); err == nil && g.Combinator != "" {
rules[i] = g
continue
}
return errors.New("Invalid json. Neither a Rule nor a RuleGroup: " + string(rawRule))
}
*rs = rules
return nil
}
var SmartPlaylistFields = []string{
"title",
"album",
"artist",
"albumartist",
"albumartwork",
"tracknumber",
"discnumber",
"year",
"size",
"compilation",
"dateadded",
"datemodified",
"discsubtitle",
"comment",
"lyrics",
"sorttitle",
"sortalbum",
"sortartist",
"sortalbumartist",
"albumtype",
"albumcomment",
"catalognumber",
"filepath",
"filetype",
"duration",
"bitrate",
"bpm",
"channels",
"genre",
"loved",
"lastplayed",
"playcount",
"rating",
}

101
model/smartplaylist_test.go
View file

@ -1,101 +0,0 @@
package model_test
import (
"bytes"
"encoding/json"
"github.com/navidrome/navidrome/model"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("SmartPlaylist", func() {
var goObj model.SmartPlaylist
var jsonObj string
BeforeEach(func() {
goObj = model.SmartPlaylist{
RuleGroup: model.RuleGroup{
Combinator: "and", Rules: model.Rules{
model.Rule{Field: "title", Operator: "contains", Value: "love"},
model.Rule{Field: "year", Operator: "is in the range", Value: []int{1980, 1989}},
model.Rule{Field: "loved", Operator: "is true"},
model.Rule{Field: "lastPlayed", Operator: "in the last", Value: 30},
model.RuleGroup{
Combinator: "or",
Rules: model.Rules{
model.Rule{Field: "artist", Operator: "is not", Value: "zé"},
model.Rule{Field: "album", Operator: "is", Value: "4"},
},
},
}},
Order: "artist asc",
Limit: 100,
}
var b bytes.Buffer
err := json.Compact(&b, []byte(`
{
"combinator":"and",
"rules":[
{
"field":"title",
"operator":"contains",
"value":"love"
},
{
"field":"year",
"operator":"is in the range",
"value":[
1980,
1989
]
},
{
"field":"loved",
"operator":"is true"
},
{
"field":"lastPlayed",
"operator":"in the last",
"value":30
},
{
"combinator":"or",
"rules":[
{
"field":"artist",
"operator":"is not",
"value":"zé"
},
{
"field":"album",
"operator":"is",
"value":"4"
}
]
}
],
"order":"artist asc",
"limit":100
}`))
if err != nil {
panic(err)
}
jsonObj = b.String()
})
It("finds all fields", func() {
Expect(goObj.Fields()).To(ConsistOf("title", "year", "loved", "lastPlayed", "artist", "album"))
})
It("marshals to JSON", func() {
j, err := json.Marshal(goObj)
Expect(err).ToNot(HaveOccurred())
Expect(string(j)).To(Equal(jsonObj))
})
It("is reversible to/from JSON", func() {
var newObj model.SmartPlaylist
err := json.Unmarshal([]byte(jsonObj), &newObj)
Expect(err).ToNot(HaveOccurred())
j, err := json.Marshal(newObj)
Expect(err).ToNot(HaveOccurred())
Expect(string(j)).To(Equal(jsonObj))
})
})