diff --git a/libraries/database/broadcasts.py b/libraries/database/broadcasts.py
index 8c02f160b55ec69ce9f13f0962237aef9d1fc0c3..b827412602d434b2ce450ecb4a9eb2163eed717c 100644
--- a/libraries/database/broadcasts.py
+++ b/libraries/database/broadcasts.py
@@ -43,130 +43,76 @@ from modules.base.simpleutil import SimpleUtil
class AuraDatabaseModel():
+ """
+ AuraDataBaseModel.
+
+ Holding all tables and relationships for the engine.
+ """
logger = None
+
def __init__(self):
+ """
+ Constructor.
+ """
self.logger = logging.getLogger("AuraEngine")
+
def store(self, add=False, commit=False):
+ """
+ Store to the database
+ """
if add:
DB.session.add(self)
if commit:
DB.session.commit()
+
def delete(self, commit=False):
+ """
+ Delete from the database
+ """
DB.session.delete(self)
-# current_db_sessions = DB.session.object_session(self)
-# current_db_sessions.delete(self)
-# return
-# DB.session.delete(self)
if commit:
DB.session.commit()
+
def _asdict(self):
return self.__dict__
@staticmethod
def recreate_db(systemexit = False):
+ """
+ Re-creates the database for developments purposes.
+ """
manualschedule = Schedule()
manualschedule.schedule_id = 0
manualschedule.show_name = "Manual Show"
-
-# self.logger.debug("Recreating Database...")
+ self.logger.debug("Recreating Database...")
DB.drop_all()
-# self.logger.debug("all dropped. creating...")
+ self.logger.debug("All dropped. creating...")
DB.create_all()
# self.logger.debug("inserting manual scheduling possibility and fallback trackservice schedule")
# DB.session.add(manualschedule)
# db.session.add(fallback_trackservice_schedule)
# self.logger.debug("all created. commiting...")
DB.session.commit()
-# self.logger.debug("Database recreated!")
+ self.logger.debug("Database recreated!")
if systemexit:
sys.exit(0)
-# ------------------------------------------------------------------------------------------ #
-# class Schedule(DB.Model, AuraDatabaseModel):
-# """
-# One specific Schedule for a show on a timeslot
-# """
-# __tablename__ = 'schedule'
-#
-# # primary and foreign keys
-# schedule_start = Column(DateTime, primary_key=True)
-#
-# schedule_end = Column(DateTime)
-# schedule_id = Column(Integer) #, primary_key=True, autoincrement=False)
-# show_id = Column(Integer) # well, in fact not needed..
-# show_name = Column(String(256))
-# show_hosts = Column(String(256))
-# funding_category = Column(String(256))
-# comment = Column(String(512))
-# languages = Column(String(256))
-# type = Column(String(256))
-# category = Column(String(256))
-# topic = Column(String(256))
-# musicfocus = Column(String(256))
-#
-# is_repetition = Column(Boolean())
-#
-# playlist_id = Column(Integer, ForeignKey("playlist.playlist_id"))
-# timeslot_fallback_id = Column(Integer)
-# show_fallback_id = Column(Integer)
-# station_fallback_id = Column(Integer)
-#
-# playlist = relationship("Playlist", foreign_keys=[playlist_id], lazy="joined")
-# # timeslot_fallback = relationship("Playlist", foreign_keys=[timeslot_fallback_id], lazy="joined")
-# # show_fallback = relationship("Playlist", foreign_keys=[show_fallback_id], lazy="joined")
-# # station_fallback = relationship("Playlist", foreign_keys=[station_fallback_id], lazy="joined")
-#
-# @staticmethod
-# def select_all():
-# # fetching all entries
-# all_entries = DB.session.query(Schedule).filter().order_by(Schedule.schedule_start).all()
-# return all_entries
-#
-# @staticmethod
-# def select_by_id(id):
-# entry = DB.session.query(Schedule).filter(Schedule.schedule_id == id).first()
-# return entry
-# @staticmethod
-# def select_act_programme():
-# #DB.session.query(Schedule).filter
-# # fetching all from today to ..
-# today = datetime.date.today()
-# all_entries = DB.session.query(Schedule).filter(Schedule.schedule_start >= today).order_by(Schedule.schedule_start).all()
-#
-# return all_entries
-#
#
-# @staticmethod
-# def drop_the_future(timedelta):
-# then = datetime.datetime.now() + timedelta
+# SCHEDULES & PLAYLISTS
#
-# # is this really necessary?
-# future_entries = DB.session.query(Schedule).filter(Schedule.schedule_start > then)
-# for e in future_entries:
-# e.delete()
-# DB.session.commit()
-#
-# def get_length(self):
-# sec1 = int(datetime.datetime.strptime(self.start[0:16].replace(" ", "T"), "%Y-%m-%dT%H:%M").strftime("%s"))
-# sec2 = int(datetime.datetime.strptime(self.end[0:16].replace(" ", "T"), "%Y-%m-%dT%H:%M").strftime("%s"))
-# len = sec2 - sec1
-# return len
-#
-# # ------------------------------------------------------------------------------------------ #
-# def __str__(self):
-# return "ScheduleID: #" + str(self.schedule_id) + " Showname: " + self.show_name + " starts @ " + str(self.schedule_start)
-# ------------------------------------------------------------------------------------------ #
+
class Schedule(DB.Model, AuraDatabaseModel):
"""
- One specific Schedule for a show on a timeslot
+ One specific Schedule for a show on a timeslot.
+ Holding references to playlists and fallback-playlists.
"""
__tablename__ = 'schedule'
@@ -246,8 +192,10 @@ class Schedule(DB.Model, AuraDatabaseModel):
-# ------------------------------------------------------------------------------------------ #
class Playlist(DB.Model, AuraDatabaseModel):
+ """
+ The playlist containing playlist entries.
+ """
__tablename__ = 'playlist'
# pk,fk
@@ -262,9 +210,12 @@ class Playlist(DB.Model, AuraDatabaseModel):
fallback_type = Column(Integer)
entry_count = Column(Integer)
+
@staticmethod
def select_all():
- # fetching all entries
+ """
+ Fetches all entries
+ """
all_entries = DB.session.query(Playlist).filter(Playlist.fallback_type == 0).all()
cnt = 0
@@ -274,6 +225,7 @@ class Playlist(DB.Model, AuraDatabaseModel):
return all_entries
+
@staticmethod
def select_playlist_for_schedule(datetime, playlist_id):
"""
@@ -360,9 +312,10 @@ class Playlist(DB.Model, AuraDatabaseModel):
-
-# ------------------------------------------------------------------------------------------ #
class PlaylistEntry(DB.Model, AuraDatabaseModel):
+ """
+ Playlist entries are the individual items of a playlist such as audio files.
+ """
__tablename__ = 'playlist_entry'
# primary keys
@@ -440,8 +393,11 @@ class PlaylistEntry(DB.Model, AuraDatabaseModel):
-# ------------------------------------------------------------------------------------------ #
+
class PlaylistEntryMetaData(DB.Model, AuraDatabaseModel):
+ """
+ Metadata for a playlist entry such as the artist and track name.
+ """
__tablename__ = "playlist_entry_metadata"
artificial_id = Column(Integer, primary_key=True)
@@ -458,6 +414,211 @@ class PlaylistEntryMetaData(DB.Model, AuraDatabaseModel):
return DB.session.query(PlaylistEntry).filter(PlaylistEntryMetaData.artificial_entry_id == artificial_playlistentry_id).first()
+
+#
+# TRACK SERVICE
+#
+
+
+class TrackService(DB.Model, AuraDatabaseModel):
+ """
+ TrackService holding track-service items consisting of
+ """
+ __tablename__ = 'trackservice'
+
+ trackservice_id = Column(Integer, primary_key=True, autoincrement=True)
+ schedule_entry_id = Column(Integer, ForeignKey("schedule_entry.id"))
+ playlist_id = Column(Integer, nullable=False)
+ entry_num = Column(Integer, nullable=False)
+ source = Column(String(255), nullable=False)
+ start = Column(DateTime, nullable=False, default=func.now())
+
+ __table_args__ = (
+ ForeignKeyConstraint(['playlist_id', 'entry_num'], ['schedule_entry.playlist_id', 'schedule_entry.entry_num']),
+ )
+ schedule_entry = relationship("ScheduleEntry", primaryjoin="and_(TrackService.playlist_id==ScheduleEntry.playlist_id, TrackService.entry_num==ScheduleEntry.entry_num)", lazy="joined")
+
+ schedule = relationship("Schedule", foreign_keys=[schedule_id], lazy="joined")
+ trackservice_entry = relationship("ScheduleEntry", foreign_keys=[playlist_id, entry_num], lazy="joined")
+ schedule_entry = relationship("ScheduleEntry", primaryjoin="and_(TrackService.schedule_entry_id==ScheduleEntry.id)", lazy="joined")
+
+
+ @staticmethod
+ def select_one(trackservice_id):
+ """
+ Select one specific track-service item by ID.
+ """
+ return DB.session.query(TrackService).filter(TrackService.trackservice_id == trackservice_id).first()
+
+
+ @staticmethod
+ def select_by_day(day):
+ """
+ Select the track-service items for a day.
+ """
+ day_plus_one = day + datetime.timedelta(days=1)
+ tracks = DB.session.query(TrackService).filter(TrackService.start >= str(day), TrackService.start < str(day_plus_one)).all()
+ return tracks
+
+
+ @staticmethod
+ def select_by_range(from_day, to_day):
+ """
+ Selects the track-service items for a day range.
+ """
+ tracks = DB.session.query(TrackService).filter(TrackService.start >= str(from_day),
+ TrackService.start < str(to_day)).all()
+ return tracks
+
+
+ def __str__(self):
+ """
+ Convert to String.
+ """
+ return "TrackServiceID: #" + str(self.trackservice_id) + " playlist_id: " + str(self.playlist_id) + " started @ " + str(self.start) + " and played " + self.source
+
+
+
+class TrackServiceSchedule(db.Model, AuraDatabaseModel):
+ """
+ Trackservice is tracking every schedule.
+ """
+ __tablename__ = 'trackservice_schedule'
+
+ # primary and foreign keys
+ ts_schedule_id = Column(Integer, primary_key=True, autoincrement=True)
+ schedule_id = Column(Integer, ForeignKey("schedule.schedule_id"))
+ schedule = relationship("Schedule", foreign_keys=[schedule_id], lazy="joined")
+
+ # ------------------------------------------------------------------------------------------ #
+ @staticmethod
+ def select_one(schedule_id):
+ # damn BAND-AID
+ # db.session.commit()
+
+ return db.session.query(ScheduleEntry).filter(TrackServiceSchedule.schedule_id == schedule_id).first()
+
+
+
+class TrackServiceScheduleEntry(db.Model, AuraDatabaseModel):
+ """
+ And a schedule can have multiple entries
+ """
+ __tablename__ = 'trackservice_entry'
+
+ # primary and foreign keys. the foreign keys here can be null, because of fallback stuff
+ ts_entry_id = Column(Integer, primary_key=True, autoincrement=True)
+ ts_schedule_id = Column(Integer, ForeignKey("trackservice_schedule.ts_schedule_id"), nullable=True)
+ playlist_id = Column(Integer, nullable=True)
+ entry_num = Column(Integer, nullable=True)
+
+ fallback = Column(Boolean, default=False)
+ fallback_start = Column(DateTime, nullable=True, default=None)
+ source = Column(String(256), nullable=True, default=None)
+
+ # foreign key definitions
+ __table_args__ = (
+ ForeignKeyConstraint(['playlist_id', 'entry_num'], ['schedule_entry.playlist_id', 'schedule_entry.entry_num']),
+ )
+
+ trackservice_schedule = relationship("TrackServiceSchedule", foreign_keys=[ts_schedule_id], lazy="joined")
+ #trackservice_entry = relationship("ScheduleEntry", foreign_keys=[playlist_id, entry_num], lazy="joined")
+ trackservice_entry = relationship("ScheduleEntry", primaryjoin="and_(TrackServiceScheduleEntry.playlist_id==ScheduleEntry.playlist_id, TrackServiceScheduleEntry.entry_num==ScheduleEntry.entry_num)" , lazy="joined")
+
+ @staticmethod
+ def select_all():
+ return db.session.query(TrackServiceScheduleEntry).filter().all()
+
+
+
+
+
+#
+# LEGACY CLASSES
+#
+
+
+
+# ------------------------------------------------------------------------------------------ #
+# class Schedule(DB.Model, AuraDatabaseModel):
+# """
+# One specific Schedule for a show on a timeslot
+# """
+# __tablename__ = 'schedule'
+#
+# # primary and foreign keys
+# schedule_start = Column(DateTime, primary_key=True)
+#
+# schedule_end = Column(DateTime)
+# schedule_id = Column(Integer) #, primary_key=True, autoincrement=False)
+# show_id = Column(Integer) # well, in fact not needed..
+# show_name = Column(String(256))
+# show_hosts = Column(String(256))
+# funding_category = Column(String(256))
+# comment = Column(String(512))
+# languages = Column(String(256))
+# type = Column(String(256))
+# category = Column(String(256))
+# topic = Column(String(256))
+# musicfocus = Column(String(256))
+#
+# is_repetition = Column(Boolean())
+#
+# playlist_id = Column(Integer, ForeignKey("playlist.playlist_id"))
+# timeslot_fallback_id = Column(Integer)
+# show_fallback_id = Column(Integer)
+# station_fallback_id = Column(Integer)
+#
+# playlist = relationship("Playlist", foreign_keys=[playlist_id], lazy="joined")
+# # timeslot_fallback = relationship("Playlist", foreign_keys=[timeslot_fallback_id], lazy="joined")
+# # show_fallback = relationship("Playlist", foreign_keys=[show_fallback_id], lazy="joined")
+# # station_fallback = relationship("Playlist", foreign_keys=[station_fallback_id], lazy="joined")
+#
+# @staticmethod
+# def select_all():
+# # fetching all entries
+# all_entries = DB.session.query(Schedule).filter().order_by(Schedule.schedule_start).all()
+# return all_entries
+#
+# @staticmethod
+# def select_by_id(id):
+# entry = DB.session.query(Schedule).filter(Schedule.schedule_id == id).first()
+# return entry
+# @staticmethod
+# def select_act_programme():
+# #DB.session.query(Schedule).filter
+# # fetching all from today to ..
+# today = datetime.date.today()
+# all_entries = DB.session.query(Schedule).filter(Schedule.schedule_start >= today).order_by(Schedule.schedule_start).all()
+#
+# return all_entries
+#
+
+#
+# @staticmethod
+# def drop_the_future(timedelta):
+# then = datetime.datetime.now() + timedelta
+#
+# # is this really necessary?
+# future_entries = DB.session.query(Schedule).filter(Schedule.schedule_start > then)
+# for e in future_entries:
+# e.delete()
+# DB.session.commit()
+#
+# def get_length(self):
+# sec1 = int(datetime.datetime.strptime(self.start[0:16].replace(" ", "T"), "%Y-%m-%dT%H:%M").strftime("%s"))
+# sec2 = int(datetime.datetime.strptime(self.end[0:16].replace(" ", "T"), "%Y-%m-%dT%H:%M").strftime("%s"))
+# len = sec2 - sec1
+# return len
+#
+# # ------------------------------------------------------------------------------------------ #
+# def __str__(self):
+# return "ScheduleID: #" + str(self.schedule_id) + " Showname: " + self.show_name + " starts @ " + str(self.schedule_start)
+
+# ------------------------------------------------------------------------------------------ #
+
+
+
# ------------------------------------------------------------------------------------------ #
#class PlaylistEntry(DB.Model, AuraDatabaseModel):
# __tablename__ = 'playlist_entry'