def insertrows(self, position, rows):
""" only used to create new rows (would work properly for "add to group" imo) """
if self.lst == None:
self.lst = []
self._checksession()
if self.gtmode:
grp = self.session.query(Group).filter(Group.name==self.prevgroup).one()
self.session.add(grp)
for row in range(position, position+rows):
nt = Track("","",True,0)
ngt = GroupTrack(int(row) + 1, 0, 0)
ngt.track = nt
grp.grouptracks.append(ngt)
self.lst.insert(row, ngt)
self.stats.add(nt)
self.session.add(nt)
self.session.add(ngt)
else:
for row in range(position, position+rows):
nt = Track("","",True,0)
self.stats.add(nt)
self.lst.insert(row, nt)
self.session.add(nt)
self.session.commit()
def insertExampleData(self):
self.getSession()
g1 = Group("Group 1")
g2 = Group("Group 2")
g2.fav = True
t1 = Track("Bob", "Hello World!", False, 1)
t2 = Track("Joe", "How are you doing?", True, 3)
t3 = Track("Jim", "Can't stop dancing", False, 5)
t4 = Track("Tom", "A simple melody", True, 9)
gt1_1 = GroupTrack(1, 0, 100)
gt1_1.track = t1
gt1_2 = GroupTrack(2, 100, 200)
gt1_2.track = t2
g1.grouptracks.append(gt1_1)
g1.grouptracks.append(gt1_2)
gt2_2 = GroupTrack(1, 0, 200)
gt2_2.track = t2
gt2_3 = GroupTrack(2, 200, 150)
gt2_3.track = t3
g2.grouptracks.append(gt2_2)
g2.grouptracks.append(gt2_3)
self.session.add_all([g1, g2, t1, t2, t3, t4, gt1_1, gt1_2, gt2_2, gt2_3])
self.session.commit()
def orderingconvert(self):
"""convert ordering between group mode and all tracks mode"""
# self.prevgroup indicates the previous mode
newordering = []
newsortcol = None
to_track = (self.prevgroup != "")
for oo in self.ordering:
# oo is from interval [-inf;-1] [1;inf]
# it must be converted to column index, sign remebered and then applied afterwards
sign = oo > 0
oo = oo - 1 if sign else - 1 - oo
rr = GroupTrack.translateorder(to_track, oo)
if rr < 0:
continue
#if newsortcol == None: # the first ordering is the most recent
newsortcol = rr + 1 if sign else - 1 - oo
newordering.append(newsortcol)
# backup is currently useful only for grouptracks (switching from track)
if to_track: # to track - save backup
self.ordbackup = None
if not self.ordering:
self.ordbackup = 1
elif abs(self.ordering[-1]) == 1:
self.ordbackup = self.ordering[-1]
else: # to grouptrack - restore backup
if self.ordbackup != None:
newsortcol = self.ordbackup
newordering.append(newsortcol)
self.ordbackup = None
self.ordering = newordering
return newsortcol
def addtogroup(self, rows, gid, force=False):
'''
add tracks given by indices in rows to a group given by gid
do not add the track if the group already contains it
'''
gg = self.session.query(Group).filter(Group.idno == gid).one()
tids = {}
lastno = 0 # determine new number for the track
for gt in gg.grouptracks:
if gt.no > lastno:
lastno = gt.no
tids[gt.track.idno] = None
lastno += 1
self._checksession()
addstat = False
if self.gtmode:
addstat = (gg == self.lst[0].group)
# duplicities (and their captions) - tracks that are already in the group
d = []
dc = ""
for rr in rows:
tt = self.lst[rr]
if self.gtmode:
tt = tt.track
if tt.idno in tids and not force:
d.append(rr)
dc += "\t" + tt.menucaption() + "\n"
continue
gt = GroupTrack(lastno, 0, 0)
gt.track = tt
gg.grouptracks.append(gt)
if addstat:
self.stats.add(tt,t=False)
self.session.add(gt)
lastno += 1
self.session.commit()
dc = dc.strip()
return d, dc
def isCheck(self, col):
if self.gtmode:
return GroupTrack.isCheck(col)
else:
return Track.isCheck(col)
def isStar(self, col):
if self.gtmode:
return GroupTrack.isStar(col)
else:
return Track.isStar(col)
def setfilter(self, rule="", group="", maxrows=0, page=1, orderby=None, orderbyasc=True):
'''
make a new query by the rule provided, get maxrows results, skip (page - 1)*maxrows results
default values get an unsorted list of all the tracks (tracks are always sorted by id)
returns lst list for convenience and a feedback list
feedback is a list of tuples with name and value
if rule is None previous value are used except for orderby and orderbyasc
'''
self._checksession()
#print('setfilter(rule="{}", group="{}", maxrows={}, page={}, orderby={}, orderbyasc={})'.format
# (rule, group, maxrows, page, orderby, orderbyasc))
fb = []
if self.stats.empty():
self.stats.total = self.session.query(Track).count()
if rule is None and group is None:
rule = self.prevrule
group = self.prevgroup
maxrows = self.prevmax
page = self.prevpage
if not type(maxrows) is int:
maxrows = 0
fb.append(("max", 0))
# when group changes, reset page; when mode changes, keep and convert sort order
newsortcol = None
if group != self.prevgroup:
if group == "" or self.prevgroup == "": # mode changed
newsortcol = self.orderingconvert()
if newsortcol:
fb.append(("sortbycol", newsortcol))
fb.append(("page", 1))
page = 1
# if max changes reset page
if maxrows != self.prevmax:
fb.append(("page", 1))
page = 1
# "register" new orderby
if orderby != None:
assert(newsortcol == None)
# new orderby resets page to 1
fb.append(("page", 1))
page = 1
# shift orderby value to clearly distinguish between asc and desc even for 0
orderno = orderby + 1
ordernosign = orderno if orderbyasc else -orderno
if not self.ordering or self.ordering[-1] != ordernosign:
self.ordbackup = None
if orderno in self.ordering:
self.ordering.remove(orderno)
elif -orderno in self.ordering:
self.ordering.remove(-orderno)
self.ordering.append(ordernosign)
#print("ordering", self.ordering)
# creating basic query
q = None
if group == "":
self.gtmode = False
q = self.session.query(Track)
else:
self.gtmode = True
q = self.session.query(GroupTrack).join(Track).join(Group)
q = q.filter(GroupTrack.groupid==Group.idno).filter(Group.name==group)
#rule filter
if rule != "":
q = self.buildquery(q, rule)
#sorting - remeber the shift between orderby and orderno
if self.ordering != None and len(self.ordering) > 0:
for on in reversed(self.ordering):
if on < 0:
oby = -1 - on
ofun = sqlalchemy.sql.expression.desc
else:
oby = on - 1
ofun = sqlalchemy.sql.expression.asc
if self.gtmode:
q = q.order_by(ofun(GroupTrack.colbycol(oby)))
else:
q = q.order_by(ofun(Track.colbycol(oby)))
#by default or as a last rule, sort tracks by trackid, grouptracks by number
if self.gtmode:
q = q.order_by(GroupTrack.no)
else:
q = q.order_by(Track.idno)
# query is prepared, execute it
if maxrows == 0:
self.lst = list(q.all())
elif maxrows == 1:
self.lst = q[(page-1*maxrows)]
else:
self.lst = q[(page-1)*maxrows:page*maxrows]
self.stats.newfilter(self.lst, q.count(), q.filter(Track.new == True).count())
# remember filter for sorting
self.prevrule = rule
self.prevgroup = group
self.prevmax = maxrows
self.prevpage = page
# return lst (for convenience) and feedback
return self.lst, fb
