19339386857

Committed 13 Nov 2025 04:58PM UTC coverage: 23.81%. First build

Build # 19339386857

Build Type

Pull #2970

github

Committed by

brotherlogic

Commit Message

Focus on very old records from the outset

Pull Request Pull Request #2970: Focus on very old records from the outset

Run Details

1 of 5 new or added lines in 1 file covered. (20.0%)

105 of 441 relevant lines covered (23.81%)

0.29 hits per line

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

53.55

/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
        }

        // Wait for pending updates
        if rec.GetMetadata().GetNeedsGramUpdate() {
                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
        }

        return rec.GetRelease().GetFolderId() == 812802 || rec.GetRelease().GetFolderId() == 7651472 || rec.GetRelease().GetFolderId() == 7664293 || rec.GetRelease().GetFolderId() == 7665013
}

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, force12 bool, old bool) (*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)

                if force12 && rc.GetMetadata().GetFiledUnder() != pbrc.ReleaseMetadata_FILE_12_INCH {
                        continue
                }

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

brotherlogic / recordgetter / 19339386857

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