8617337278

Committed 09 Apr 2024 02:19PM UTC coverage: 25.879%. First build

Build # 8617337278

Build Type

Pull #1512

github

Committed by

brotherlogic

Commit Message

Also include tapes

Pull Request Pull Request #1512: Also include tapes

Run Details

0 of 1 new or added line in 1 file covered. (0.0%)

103 of 398 relevant lines covered (25.88%)

0.32 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

53.33

/recordgetterutils.go

package main

import (
        "fmt"
        "math/rand"
        "strings"
        "time"

        "golang.org/x/net/context"

        pbrc "github.com/brotherlogic/recordcollection/proto"
        pb "github.com/brotherlogic/recordgetter/proto"
        pbro "github.com/brotherlogic/recordsorganiser/proto"
)

func (s *Server) validate(rec *pbrc.Record, typ pb.RequestType) bool {
        if rec.GetMetadata().GetDateArrived() == 0 {
                return false
        }

        // Check the type
        if typ == pb.RequestType_CD_FOCUS && rec.GetMetadata().GetFiledUnder() != pbrc.ReleaseMetadata_FILE_CD {
                if rec.GetMetadata().GetFiledUnder() != pbrc.ReleaseMetadata_FILE_TAPE {
                return false
        }
}

        if typ == pb.RequestType_DIGITAL && rec.GetMetadata().GetFiledUnder() != pbrc.ReleaseMetadata_FILE_DIGITAL {
                return false
        }

        // Records should be in the listening pile
        if s.visitors {
                return rec.GetRelease().GetFolderId() == 812802 &&
                        (rec.GetMetadata().GetFiledUnder() == pbrc.ReleaseMetadata_FILE_CD ||
                                rec.GetMetadata().GetFiledUnder() == pbrc.ReleaseMetadata_FILE_DIGITAL)
        } else {
                return rec.GetRelease().GetFolderId() == 812802
        }
}

func (s *Server) isFilable(rc *pbrc.Record) bool {
        return rc.GetMetadata().GetGoalFolder() == 242017 && rc.GetRelease().GetFormatQuantity() <= 3
}

func (s *Server) getCategoryRecord(ctx context.Context, t time.Time, c pbrc.ReleaseMetadata_Category, state *pb.State, typ pb.RequestType) (*pbrc.Record, error) {
        pDate := int64(0)
        var newRec *pbrc.Record
        newRec = nil

        recs, err := s.rGetter.getRecordsInCategory(ctx, c)

        if err != nil {
                return nil, err
        }

        for _, id := range recs {
                rc, err := s.rGetter.getRelease(ctx, id)
                isDigital := rc.GetMetadata().GetFiledUnder() != pbrc.ReleaseMetadata_FILE_12_INCH &&
                        rc.GetMetadata().GetFiledUnder() != pbrc.ReleaseMetadata_FILE_7_INCH

                // Include CDs in sale determinations at home
                if c == pbrc.ReleaseMetadata_STAGED_TO_SELL {
                        isDigital = isDigital && rc.GetMetadata().GetFiledUnder() != pbrc.ReleaseMetadata_FILE_CD
                }
                s.CtxLog(ctx, fmt.Sprintf("SKIP %v-> %v and %v", id, typ, rc.GetMetadata().GetFiledUnder() == pbrc.ReleaseMetadata_FILE_DIGITAL))
                if ((typ == pb.RequestType_CD_FOCUS || typ == pb.RequestType_DIGITAL) && !isDigital) ||
                        (!(typ == pb.RequestType_CD_FOCUS || typ == pb.RequestType_DIGITAL) && isDigital) {
                        continue
                }

                if !s.validate(rc, typ) {
                        s.CtxLog(ctx, fmt.Sprintf("SKIP %v -> does not validate", id))
                        continue
                }

                s.CtxLog(ctx, fmt.Sprintf("Evaluating %v from %v", rc.GetRelease().GetTitle(), c))
                if err == nil && rc != nil {
                        if (pDate == 0 || rc.GetMetadata().DateAdded < pDate) &&
                                rc.GetRelease().Rating == 0 &&
                                !rc.GetMetadata().GetDirty() &&
                                rc.GetMetadata().SetRating == 0 {
                                if s.dateFine(rc, t, state) && !s.needsRip(rc) {
                                        pDate = rc.GetMetadata().DateAdded
                                        newRec = rc
                                } else {
                                        s.CtxLog(ctx, fmt.Sprintf("Date is not fine for %v", id))
                                }
                        } else {
                                s.CtxLog(ctx, fmt.Sprintf("Did not pass go %v -> %v: %v (%v), %v, %v", id, pDate, newRec.GetRelease().GetInstanceId(), rc.GetRelease().GetRating(), rc.GetMetadata().GetDirty(), rc.GetMetadata().GetSetRating()))
                        }
                }
        }

        if newRec != nil {
                return newRec, nil
        }

        return nil, nil
}

func (s *Server) getInFolderWithCategory(ctx context.Context, t time.Time, folder int32, cat pbrc.ReleaseMetadata_Category, state *pb.State, digitalOnly bool, filable bool) (*pbrc.Record, error) {
        recs, err := s.rGetter.getRecordsInFolder(ctx, folder)
        if err != nil {
                return nil, err
        }

        for _, id := range recs {
                r, err := s.rGetter.getRelease(ctx, id)
                if (digitalOnly && r.GetMetadata().GetFiledUnder() != pbrc.ReleaseMetadata_FILE_DIGITAL) ||
                        (!digitalOnly && r.GetMetadata().GetFiledUnder() == pbrc.ReleaseMetadata_FILE_DIGITAL) {
                        continue
                }
                if err == nil {
                        if r.GetMetadata().GetCategory() == cat && r.GetRelease().Rating == 0 && !r.GetMetadata().GetDirty() && r.GetMetadata().SetRating == 0 {
                                if s.dateFine(r, t, state) && !s.needsRip(r) {
                                        if !filable || s.isFilable(r) {
                                                return r, nil
                                        }
                                }
                        }
                }
        }

        return nil, nil
}

func (s *Server) removeSeven(allrecs []int32, state *pb.State) []int32 {
        new := []int32{}
        for _, val := range allrecs {
                if time.Now().Sub(time.Unix(state.LastSeven, 0)) < time.Hour*2 || val != 267116 {
                        new = append(new, val)
                }
        }
        return new
}

func (s *Server) setTime(r *pbrc.Record, state *pb.State) {
        if r.GetRelease().FolderId == 267116 {
                state.LastSeven = time.Now().Unix()
        }
}

func (s *Server) getInFolders(ctx context.Context, t time.Time, folders []int32, state *pb.State, dig bool) (*pbrc.Record, error) {
        allrecs := make([]int32, 0)
        for _, folder := range folders {
                recs, err := s.rGetter.getRecordsInFolder(ctx, folder)
                if err != nil {
                        return nil, err
                }
                allrecs = append(allrecs, recs...)
        }

        allrecs = s.removeSeven(allrecs, state)

        // Shuffle allrecs to prevent bias
        rand.Seed(time.Now().UnixNano())
        rand.Shuffle(len(allrecs), func(i, j int) { allrecs[i], allrecs[j] = allrecs[j], allrecs[i] })

        for _, id := range allrecs {
                r, err := s.rGetter.getRelease(ctx, id)
                if err == nil && r != nil {
                        if r.GetRelease().Rating == 0 && !r.GetMetadata().GetDirty() && r.GetMetadata().SetRating == 0 {
                                if s.dateFine(r, t, state) && !s.needsRip(r) {
                                        s.setTime(r, state)
                                        return r, nil
                                }
                        }
                }
        }

        return nil, nil
}

func (s *Server) needsRip(r *pbrc.Record) bool {
        // Digital records don't need to be ripped
        if r.GetMetadata().GetGoalFolder() == 268147 || r.GetMetadata().GetGoalFolder() == 1433217 {
                return false
        }

        for _, f := range r.GetRelease().Formats {
                if strings.Contains(f.Name, "CD") {
                        return len(r.GetMetadata().CdPath) == 0
                }
        }

        return false
}

func (s *Server) clearScores(instanceID int32, state *pb.State) {
        i := 0
        for i < len(state.Scores) {
                if state.Scores[i].InstanceId == instanceID {
                        state.Scores[i] = state.Scores[len(state.Scores)-1]
                        state.Scores = state.Scores[:len(state.Scores)-1]
                } else {
                        i++
                }

        }
}

func (s *Server) getScore(ctx context.Context, rc *pbrc.Record, state *pb.State) int32 {
        sum := int32(0)
        count := int32(0)

        sum += rc.GetMetadata().GetSetRating()
        count++
        maxDisk := int32(1)

        scores := ""
        for _, score := range state.Scores {
                if score.InstanceId == rc.Release.InstanceId {
                        scores += fmt.Sprintf(" %v ", score)
                        sum += score.Score
                        count++

                        if score.DiskNumber >= maxDisk {
                                maxDisk = score.DiskNumber + 1
                        }
                }
        }

        //Add the score
        state.Scores = append(state.Scores, &pb.DiskScore{InstanceId: rc.GetRelease().InstanceId, DiskNumber: maxDisk, ScoreDate: time.Now().Unix(), Score: rc.GetMetadata().GetSetRating()})

        if count >= rc.Release.FormatQuantity {
                s.clearScores(rc.Release.InstanceId, state)

                //Trick Rounding
                score := int32((float64(sum) / float64(count)) + 0.5)
                return score
        }

        return -1
}

func getNumListens(rc *pbrc.Record) int32 {
        if rc.GetMetadata().GetCategory() == pbrc.ReleaseMetadata_PRE_FRESHMAN {
                return 3
        }
        return 1
}

func (s *Server) readLocations(ctx context.Context, state *pb.State) error {
        locations, err := s.org.getLocations(ctx)
        if err != nil {
                return err
        }

        state.ActiveFolders = []int32{}
        for _, location := range locations {
                if location.InPlay == pbro.Location_IN_PLAY {
                        for _, folder := range location.FolderIds {
                                state.ActiveFolders = append(state.ActiveFolders, folder)
                        }
                }
        }

        return s.saveState(ctx, state)
}

1	package main
2
3	import (
4	"fmt"
5	"math/rand"
6	"strings"
7	"time"
8
9	"golang.org/x/net/context"
10
11	pbrc "github.com/brotherlogic/recordcollection/proto"
12	pb "github.com/brotherlogic/recordgetter/proto"
13	pbro "github.com/brotherlogic/recordsorganiser/proto"
14	)
15
16	func (s Server) validate(rec pbrc.Record, typ pb.RequestType) bool {	1✔
17	if rec.GetMetadata().GetDateArrived() == 0 {	2✔
18	return false	1✔
19	}	1✔
20
21	// Check the type
22	if typ == pb.RequestType_CD_FOCUS && rec.GetMetadata().GetFiledUnder() != pbrc.ReleaseMetadata_FILE_CD {	×
NEW 23	if rec.GetMetadata().GetFiledUnder() != pbrc.ReleaseMetadata_FILE_TAPE {	×
24	return false	×
25	}	×
26	}
27
28	if typ == pb.RequestType_DIGITAL && rec.GetMetadata().GetFiledUnder() != pbrc.ReleaseMetadata_FILE_DIGITAL {	×
29	return false	×
30	}	×
31
32	// Records should be in the listening pile
33	if s.visitors {	×
34	return rec.GetRelease().GetFolderId() == 812802 &&	×
35	(rec.GetMetadata().GetFiledUnder() == pbrc.ReleaseMetadata_FILE_CD \|\|	×
36	rec.GetMetadata().GetFiledUnder() == pbrc.ReleaseMetadata_FILE_DIGITAL)	×
37	} else {	×
38	return rec.GetRelease().GetFolderId() == 812802	×
39	}	×
40	}
41
42	func (s Server) isFilable(rc pbrc.Record) bool {	×
43	return rc.GetMetadata().GetGoalFolder() == 242017 && rc.GetRelease().GetFormatQuantity() <= 3	×
44	}	×
45
46	func (s Server) getCategoryRecord(ctx context.Context, t time.Time, c pbrc.ReleaseMetadata_Category, state pb.State, typ pb.RequestType) (*pbrc.Record, error) {	1✔
47	pDate := int64(0)	1✔
48	var newRec *pbrc.Record	1✔
49	newRec = nil	1✔
50		1✔
51	recs, err := s.rGetter.getRecordsInCategory(ctx, c)	1✔
52		1✔
53	if err != nil {	2✔
54	return nil, err	1✔
55	}	1✔
56
57	for _, id := range recs {	2✔
58	rc, err := s.rGetter.getRelease(ctx, id)	1✔
59	isDigital := rc.GetMetadata().GetFiledUnder() != pbrc.ReleaseMetadata_FILE_12_INCH &&	1✔
60	rc.GetMetadata().GetFiledUnder() != pbrc.ReleaseMetadata_FILE_7_INCH	1✔
61		1✔
62	// Include CDs in sale determinations at home	1✔
63	if c == pbrc.ReleaseMetadata_STAGED_TO_SELL {	1✔
64	isDigital = isDigital && rc.GetMetadata().GetFiledUnder() != pbrc.ReleaseMetadata_FILE_CD	×
65	}	×
66	s.CtxLog(ctx, fmt.Sprintf("SKIP %v-> %v and %v", id, typ, rc.GetMetadata().GetFiledUnder() == pbrc.ReleaseMetadata_FILE_DIGITAL))	1✔
67	if ((typ == pb.RequestType_CD_FOCUS \|\| typ == pb.RequestType_DIGITAL) && !isDigital) \|\|	1✔
68	(!(typ == pb.RequestType_CD_FOCUS \|\| typ == pb.RequestType_DIGITAL) && isDigital) {	2✔
69	continue	1✔
70	}
71
72	if !s.validate(rc, typ) {	×
73	s.CtxLog(ctx, fmt.Sprintf("SKIP %v -> does not validate", id))	×
74	continue	×
75	}
76
77	s.CtxLog(ctx, fmt.Sprintf("Evaluating %v from %v", rc.GetRelease().GetTitle(), c))	×
78	if err == nil && rc != nil {	×
79	if (pDate == 0 \|\| rc.GetMetadata().DateAdded < pDate) &&	×
80	rc.GetRelease().Rating == 0 &&	×
81	!rc.GetMetadata().GetDirty() &&	×
82	rc.GetMetadata().SetRating == 0 {	×
83	if s.dateFine(rc, t, state) && !s.needsRip(rc) {	×
84	pDate = rc.GetMetadata().DateAdded	×
85	newRec = rc	×
86	} else {	×
87	s.CtxLog(ctx, fmt.Sprintf("Date is not fine for %v", id))	×
88	}	×
89	} else {	×
90	s.CtxLog(ctx, fmt.Sprintf("Did not pass go %v -> %v: %v (%v), %v, %v", id, pDate, newRec.GetRelease().GetInstanceId(), rc.GetRelease().GetRating(), rc.GetMetadata().GetDirty(), rc.GetMetadata().GetSetRating()))	×
91	}	×
92	}
93	}
94
95	if newRec != nil {	1✔
96	return newRec, nil	×
97	}	×
98
99	return nil, nil	1✔
100	}
101
102	func (s Server) getInFolderWithCategory(ctx context.Context, t time.Time, folder int32, cat pbrc.ReleaseMetadata_Category, state pb.State, digitalOnly bool, filable bool) (*pbrc.Record, error) {	1✔
103	recs, err := s.rGetter.getRecordsInFolder(ctx, folder)	1✔
104	if err != nil {	2✔
105	return nil, err	1✔
106	}	1✔
107
108	for _, id := range recs {	2✔
109	r, err := s.rGetter.getRelease(ctx, id)	1✔
110	if (digitalOnly && r.GetMetadata().GetFiledUnder() != pbrc.ReleaseMetadata_FILE_DIGITAL) \|\|	1✔
111	(!digitalOnly && r.GetMetadata().GetFiledUnder() == pbrc.ReleaseMetadata_FILE_DIGITAL) {	1✔
112	continue	×
113	}
114	if err == nil {	2✔
115	if r.GetMetadata().GetCategory() == cat && r.GetRelease().Rating == 0 && !r.GetMetadata().GetDirty() && r.GetMetadata().SetRating == 0 {	1✔
116	if s.dateFine(r, t, state) && !s.needsRip(r) {	×
117	if !filable \|\| s.isFilable(r) {	×
118	return r, nil	×
119	}	×
120	}
121	}
122	}
123	}
124
125	return nil, nil	1✔
126	}
127
128	func (s Server) removeSeven(allrecs []int32, state pb.State) []int32 {	1✔
129	new := []int32{}	1✔
130	for _, val := range allrecs {	2✔
131	if time.Now().Sub(time.Unix(state.LastSeven, 0)) < time.Hour*2 \|\| val != 267116 {	2✔
132	new = append(new, val)	1✔
133	}	1✔
134	}
135	return new	1✔
136	}
137
138	func (s Server) setTime(r pbrc.Record, state *pb.State) {	1✔
139	if r.GetRelease().FolderId == 267116 {	1✔
140	state.LastSeven = time.Now().Unix()	×
141	}	×
142	}
143
144	func (s Server) getInFolders(ctx context.Context, t time.Time, folders []int32, state pb.State, dig bool) (*pbrc.Record, error) {	1✔
145	allrecs := make([]int32, 0)	1✔
146	for _, folder := range folders {	2✔
147	recs, err := s.rGetter.getRecordsInFolder(ctx, folder)	1✔
148	if err != nil {	2✔
149	return nil, err	1✔
150	}	1✔
151	allrecs = append(allrecs, recs...)	1✔
152	}
153
154	allrecs = s.removeSeven(allrecs, state)	1✔
155		1✔
156	// Shuffle allrecs to prevent bias	1✔
157	rand.Seed(time.Now().UnixNano())	1✔
158	rand.Shuffle(len(allrecs), func(i, j int) { allrecs[i], allrecs[j] = allrecs[j], allrecs[i] })	1✔
159
160	for _, id := range allrecs {	2✔
161	r, err := s.rGetter.getRelease(ctx, id)	1✔
162	if err == nil && r != nil {	2✔
163	if r.GetRelease().Rating == 0 && !r.GetMetadata().GetDirty() && r.GetMetadata().SetRating == 0 {	2✔
164	if s.dateFine(r, t, state) && !s.needsRip(r) {	2✔
165	s.setTime(r, state)	1✔
166	return r, nil	1✔
167	}	1✔
168	}
169	}
170	}
171
172	return nil, nil	1✔
173	}
174
175	func (s Server) needsRip(r pbrc.Record) bool {	1✔
176	// Digital records don't need to be ripped	1✔
177	if r.GetMetadata().GetGoalFolder() == 268147 \|\| r.GetMetadata().GetGoalFolder() == 1433217 {	2✔
178	return false	1✔
179	}	1✔
180
181	for _, f := range r.GetRelease().Formats {	2✔
182	if strings.Contains(f.Name, "CD") {	2✔
183	return len(r.GetMetadata().CdPath) == 0	1✔
184	}	1✔
185	}
186
187	return false	1✔
188	}
189
190	func (s Server) clearScores(instanceID int32, state pb.State) {	×
191	i := 0	×
192	for i < len(state.Scores) {	×
193	if state.Scores[i].InstanceId == instanceID {	×
194	state.Scores[i] = state.Scores[len(state.Scores)-1]	×
195	state.Scores = state.Scores[:len(state.Scores)-1]	×
196	} else {	×
197	i++	×
198	}	×
199
200	}
201	}
202
203	func (s Server) getScore(ctx context.Context, rc pbrc.Record, state *pb.State) int32 {	×
204	sum := int32(0)	×
205	count := int32(0)	×
206		×
207	sum += rc.GetMetadata().GetSetRating()	×
208	count++	×
209	maxDisk := int32(1)	×
210		×
211	scores := ""	×
212	for _, score := range state.Scores {	×
213	if score.InstanceId == rc.Release.InstanceId {	×
214	scores += fmt.Sprintf(" %v ", score)	×
215	sum += score.Score	×
216	count++	×
217		×
218	if score.DiskNumber >= maxDisk {	×
219	maxDisk = score.DiskNumber + 1	×
220	}	×
221	}
222	}
223
224	//Add the score
225	state.Scores = append(state.Scores, &pb.DiskScore{InstanceId: rc.GetRelease().InstanceId, DiskNumber: maxDisk, ScoreDate: time.Now().Unix(), Score: rc.GetMetadata().GetSetRating()})	×
226		×
227	if count >= rc.Release.FormatQuantity {	×
228	s.clearScores(rc.Release.InstanceId, state)	×
229		×
230	//Trick Rounding	×
231	score := int32((float64(sum) / float64(count)) + 0.5)	×
232	return score	×
233	}	×
234
235	return -1	×
236	}
237
238	func getNumListens(rc *pbrc.Record) int32 {	1✔
239	if rc.GetMetadata().GetCategory() == pbrc.ReleaseMetadata_PRE_FRESHMAN {	2✔
240	return 3	1✔
241	}	1✔
242	return 1	×
243	}
244
245	func (s Server) readLocations(ctx context.Context, state pb.State) error {	1✔
246	locations, err := s.org.getLocations(ctx)	1✔
247	if err != nil {	2✔
248	return err	1✔
249	}	1✔
250
251	state.ActiveFolders = []int32{}	1✔
252	for _, location := range locations {	2✔
253	if location.InPlay == pbro.Location_IN_PLAY {	2✔
254	for _, folder := range location.FolderIds {	2✔
255	state.ActiveFolders = append(state.ActiveFolders, folder)	1✔
256	}	1✔
257	}
258	}
259
260	return s.saveState(ctx, state)	1✔
261	}

brotherlogic / recordgetter / 8617337278

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous