models.py

#
# Aura Engine (https://gitlab.servus.at/aura/engine)
#
# Copyright (C) 2017-2020 - The Aura Engine Team.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.


import sys
import time
import logging
import datetime

import sqlalchemy as sa

from sqlalchemy.ext.declarative         import declarative_base
from sqlalchemy                         import orm
from sqlalchemy                         import BigInteger, Boolean, Column, DateTime, Integer, String, ForeignKey
from sqlalchemy.orm                     import relationship
from sqlalchemy.ext.hybrid              import hybrid_property


from modules.scheduling.types           import PlaylistType
from modules.base.config                import AuraConfig
from modules.base.utils                 import SimpleUtil, EngineUtil



# Init Config
config = AuraConfig()

# Initialize DB Model and session
engine = sa.create_engine(config.get_database_uri())
Base = declarative_base()
Base.metadata.bind = engine

class DB():
    session = orm.scoped_session(orm.sessionmaker())(bind=engine)
    Model = Base



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)
        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"
        Base.metadata.drop_all()
        Base.metadata.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()

        if systemexit:
            sys.exit(0)



#
#   SCHEDULES & PLAYLISTS
#


class Schedule(DB.Model, AuraDatabaseModel):
    """
    One specific Schedule for a show on a timeslot.
    Holding references to playlists and fallback-playlists.
    """
    __tablename__ = 'schedule'

    # Primary keys
    id = Column(Integer, primary_key=True, autoincrement=True)

    schedule_start = Column(DateTime, unique=True, index=True)
    schedule_end = Column(DateTime, unique=True, index=True)
    schedule_id = Column(Integer, unique=True)

    show_id = Column(Integer)
    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"))
    schedule_fallback_id = Column(Integer)
    show_fallback_id = Column(Integer)
    station_fallback_id = Column(Integer)
    fallback_state = PlaylistType.DEFAULT
    
    fadeouttimer = None # Used to fade-out the schedule, even when entries are longer

    playlist = relationship("Playlist",
                            primaryjoin="and_(Schedule.schedule_start==Playlist.schedule_start, Schedule.playlist_id==Playlist.playlist_id, Schedule.show_name==Playlist.show_name)",
                            back_populates="schedule")
    schedule_fallback = relationship("Playlist",
                            primaryjoin="and_(Schedule.schedule_start==Playlist.schedule_start, Schedule.schedule_fallback_id==Playlist.playlist_id, Schedule.show_name==Playlist.show_name)",
                            back_populates="schedule")
    show_fallback = relationship("Playlist",
                            primaryjoin="and_(Schedule.schedule_start==Playlist.schedule_start, Schedule.show_fallback_id==Playlist.playlist_id, Schedule.show_name==Playlist.show_name)",
                            back_populates="schedule")
    station_fallback = relationship("Playlist",
                            primaryjoin="and_(Schedule.schedule_start==Playlist.schedule_start, Schedule.station_fallback_id==Playlist.playlist_id, Schedule.show_name==Playlist.show_name)",
                            back_populates="schedule")


    @staticmethod
    def select_show_on_datetime(date_time):
        return DB.session.query(Schedule).filter(Schedule.schedule_start == date_time).first()


    @staticmethod
    def select_programme(date_from=datetime.date.today()):
        """
        Select all schedules starting from `date_from` or from today if no
        parameter is passed.

        Args:
            date_from (datetime):   Select schedules from this date and time on

        Returns:
            ([Schedule]):           List of schedules
        """
        schedules = DB.session.query(Schedule).\
            filter(Schedule.schedule_start >= date_from).\
            order_by(Schedule.schedule_start).all()

        return schedules


    @staticmethod
    def select_upcoming(n):
        """
        Selects the (`n`) upcoming schedules.
        """
        now = datetime.datetime.now()
        DB.session.commit() # Required since independend session is used.
        schedules = DB.session.query(Schedule).\
            filter(Schedule.schedule_start > str(now)).\
            order_by(Schedule.schedule_start.asc()).limit(n).all()
        
        return schedules


    @hybrid_property
    def start_unix(self):
        """
        Start time of the schedule in UNIX time.
        """
        return time.mktime(self.schedule_start.timetuple())


    @hybrid_property
    def end_unix(self):
        """
        End time of the schedule in UNIX time.
        """
        return time.mktime(self.schedule_end.timetuple())


    def as_dict(self):
        """
        Returns the schedule as a dictionary for serialization.
        """
        playlist = self.playlist

        return {
            "schedule_id": self.schedule_id,        
            "schedule_start": self.schedule_start.isoformat(),
            "schedule_end": self.schedule_end.isoformat(),

            "topic": self.topic,
            "musicfocus": self.musicfocus,
            "funding_category": self.funding_category,
            "is_repetition": self.is_repetition,
            "category": self.category,
            "languages": self.languages,
            "comment": self.comment,
            "playlist_id": self.playlist_id,
            "schedule_fallback_id": self.schedule_fallback_id,
            "show_fallback_id": self.show_fallback_id,
            "station_fallback_id": self.station_fallback_id,

            "show": {
                "name": self.show_name,
                "type": self.get_type(),
                "host": self.show_hosts
            },

            "playlist": playlist
        }


    def __str__(self):
        """
        String representation of the object.
        """
        time_start = SimpleUtil.fmt_time(self.start_unix)
        time_end = SimpleUtil.fmt_time(self.end_unix)
        return "ID#%s [Show: %s, ShowID: %s | %s - %s ]" % (str(self.schedule_id), self.show_name, str(self.show_id), time_start, time_end)



class Playlist(DB.Model, AuraDatabaseModel):
    """
    The playlist containing playlist entries.
    """
    __tablename__ = 'playlist'

    # pk,fk
    artificial_id = Column(Integer, primary_key=True)
    schedule_start = Column(DateTime, ForeignKey("schedule.schedule_start"))
    # relationships
    schedule = relationship("Schedule", uselist=False, back_populates="playlist")
    entries = relationship("PlaylistEntry", back_populates="playlist")
    # data
    playlist_id = Column(Integer, autoincrement=False)  # , ForeignKey("schedule.playlist_id"))
    show_name = Column(String(256))
    fallback_type = Column(Integer)
    entry_count = Column(Integer)


    @staticmethod
    def select_all():
        """
        Fetches all entries
        """
        all_entries = DB.session.query(Playlist).filter(Playlist.fallback_type == 0).all()

        cnt = 0
        for entry in all_entries:
            entry.programme_index = cnt
            cnt = cnt + 1

        return all_entries


    @staticmethod
    def select_playlist_for_schedule(datetime, playlist_id):
        """
        Retrieves the playlist for the given schedule identified by `start_date` and `playlist_id`

        Args:
            start_date (datetime):  Date and time when the playlist is scheduled
            playlist_id (Integer):  The ID of the playlist

        Returns:
            (Playlist):             The playlist, if existing for schedule

        Raises:
            Exception:              In case there a inconsistent database state, such es multiple playlists for given date/time.
        """
        playlist = None
        playlists = DB.session.query(Playlist).filter(Playlist.schedule_start == datetime).all()
        # FIXME There are unknown issues with the native SQL query by ID
        # playlists = DB.session.query(Playlist).filter(Playlist.schedule_start == datetime and Playlist.playlist_id == playlist_id).all()
        
        for p in playlists:
            if p.playlist_id == playlist_id:
                playlist = p
        # if playlists and len(playlists) > 1:
        #     raise Exception("Inconsistent Database State: Multiple playlists for given schedule '%s' and playlist id#%d available!" % (str(datetime), playlist_id))
        # if not playlists:
        #     return None
        # return playlists[0]
        return playlist


    @staticmethod
    def select_playlist(playlist_id):
        """
        Retrieves all paylists for that given playlist ID.

        Args:
            playlist_id (Integer):  The ID of the playlist
        
        Returns:
            (Array<Playlist>):      An array holding the playlists
        """
        return DB.session.query(Playlist).filter(Playlist.playlist_id == playlist_id).order_by(Playlist.schedule_start).all()
    

    @staticmethod
    def is_empty():
        """
        Checks if the given is empty
        """
        try:
            return not DB.session.query(Playlist).one_or_none()
        except sa.orm.exc.MultipleResultsFound:
            return False


    @hybrid_property
    def start_unix(self):
        """
        Start time of the playlist in UNIX time.
        """
        return time.mktime(self.schedule_start.timetuple())


    @hybrid_property
    def end_unix(self):
        """
        End time of the playlist in UNIX time.
        """
        return time.mktime(self.schedule_start.timetuple()) + self.duration


    @hybrid_property
    def duration(self):
        """
        Returns the total length of the playlist in seconds.

        Returns:
            (Integer):  Length in seconds
        """
        total = 0

        for entry in self.entries:
            total += entry.duration
        return total


    def as_dict(self):
        """
        Returns the playlist as a dictionary for serialization.
        """
        entries = []
        for e in self.entries:
            entries.append(e.as_dict())

        playlist = {
            "playlist_id": self.playlist_id,
            "fallback_type": self.fallback_type,
            "entry_count": self.entry_count,
            "entries": entries
        }
        return playlist


    def __str__(self):
        """
        String representation of the object.
        """
        time_start = SimpleUtil.fmt_time(self.start_unix)
        time_end = SimpleUtil.fmt_time(self.end_unix)
        return "ID#%s [items: %s | %s - %s]" % (str(self.playlist_id), str(self.entry_count), str(time_start), str(time_end))



class PlaylistEntry(DB.Model, AuraDatabaseModel):
    """
    Playlist entries are the individual items of a playlist such as audio files.
    """
    __tablename__ = 'playlist_entry'

    # primary keys
    artificial_id = Column(Integer, primary_key=True)

    # foreign keys
    artificial_playlist_id = Column(Integer, ForeignKey("playlist.artificial_id"))
    entry_num = Column(Integer) # , primary_key=True)

    uri = Column(String(1024))
    duration = Column(BigInteger)
    source = Column(String(1024))
    entry_start = Column(DateTime)
    queue_state = None # Assigned when entry is about to be queued
    channel = None # Assigned when entry is actually played
    status = None # Assigned when state changes
    
    switchtimer = None
    loadtimer = None
    fadeouttimer = None

    # relationships
    playlist = relationship("Playlist", uselist=False, back_populates="entries")
    meta_data = relationship("PlaylistEntryMetaData", uselist=False, back_populates="entry")

    @staticmethod
    def select_playlistentry_for_playlist(artificial_playlist_id, entry_num):
        return DB.session.query(PlaylistEntry).filter(PlaylistEntry.artificial_playlist_id == artificial_playlist_id, PlaylistEntry.entry_num == entry_num).first()

    @hybrid_property
    def entry_end(self):
        return self.entry_start + datetime.timedelta(seconds=self.duration)

    @hybrid_property
    def start_unix(self):
        return time.mktime(self.entry_start.timetuple())

    @hybrid_property
    def end_unix(self):
        return time.mktime(self.entry_end.timetuple())

    @hybrid_property
    def volume(self):
        return 100 # FIXME Make DB Column

    def get_type(self):
        return EngineUtil.get_channel_type(self.uri)


    def get_prev_entries(self):
        """
        Retrieves all previous entries as part of the current entry's playlist.

        Returns:
            (List):     List of PlaylistEntry
        """
        prev_entries = []
        for entry in self.playlist.entries:
            if entry.entry_start < self.entry_start:
                prev_entries.append(entry)
        return prev_entries


    def get_next_entries(self, schedule_sensitive=True):
        """
        Retrieves all following entries as part of the current entry's playlist.

        Args:
            schedule_sensitive (Boolean):   If `True` entries which start after \
                the end of the schedule are excluded

        Returns:
            (List):     List of PlaylistEntry
        """
        next_entries = []
        for entry in self.playlist.entries:
            if entry.entry_start > self.entry_start:
                if schedule_sensitive:
                    if entry.entry_start < self.playlist.schedule.schedule_end:
                        next_entries.append(entry)
                else:
                    next_entries.append(entry)
        return next_entries


    def as_dict(self):
        """
        Returns the entry as a dictionary for serialization.
        """
        if self.meta_data:
            return {
                "id": self.artificial_id,
                "duration": self.duration,
                "artist": self.meta_data.artist,
                "album": self.meta_data.album,
                "title": self.meta_data.title
            }
        return None

    def __str__(self):
        """
        String representation of the object.
        """
        time_start = SimpleUtil.fmt_time(self.start_unix)
        time_end = SimpleUtil.fmt_time(self.end_unix)
        track = self.source[-25:]
        return "PlaylistEntry #%s [%s - %s | %ssec | Source: ...%s]" % (str(self.artificial_id), time_start, time_end, self.duration, track)




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)
    artificial_entry_id = Column(Integer, ForeignKey("playlist_entry.artificial_id"))

    artist = Column(String(256))
    title = Column(String(256))
    album = Column(String(256))

    entry = relationship("PlaylistEntry", uselist=False, back_populates="meta_data")

    @staticmethod
    def select_metadata_for_entry(artificial_playlistentry_id):
        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'

#     # Primary keys
#     id = Column(Integer, primary_key=True, autoincrement=True)

#     # Foreign keys
#     track_start = Column(DateTime)
#     track_end = Column(DateTime) # Currently not used, maybe later for timing checks and multi-entry avoidance.
#     artificial_schedule_id = Column(Integer, ForeignKey("schedule.id"))
#     artificial_playlist_entry_id = Column(Integer, ForeignKey("playlist_entry.artificial_id"), nullable=True)
#     single_entry_id = Column(Integer, ForeignKey("single_entry.id"), nullable=True)

#     # Data
#     schedule = relationship("Schedule", foreign_keys=[artificial_schedule_id], lazy="joined")
#     playlist_entry = relationship("PlaylistEntry", primaryjoin="and_(TrackService.artificial_playlist_entry_id==PlaylistEntry.artificial_id)", lazy="joined")
#     single_entry = relationship("SingleEntry", foreign_keys=[single_entry_id], lazy="joined")

#     fallback_type = Column(Integer, default=0)


#     def __init__(self, entry, fallback_type=0):
#         """
#         Initializes a trackservice entry based on a playlist entry.
#         """
#         self.track_start = datetime.datetime.now()
#         # if entry.duration:
#         #     self.track_end = self.track_start + datetime.timedelta(seconds=entry.duration)
#         self.fallback_type = fallback_type

#         if fallback_type < 4:
#             self.schedule_start = entry.playlist.schedule_start
#             self.artificial_playlist_entry_id = entry.artificial_id
#             self.playlist_entry = entry
#             self.schedule = entry.playlist.schedule
#         else:
#             self.single_entry = entry


#     @hybrid_property
#     def track(self):
#         """
#         Retrieves the track information as a dictionary.
        
#         Depending on possible fallback scenarios either `playlist_entry` or `single_entry` is used as a basis:

#             - Scenario 1: No fallback, all info is gathered via the playlist entry
#             - Scenario 2: Fallback-type > 0, info is also gathered via the defined playlist entry
#             - Scenario 3: This type of fallback didn't get scheduled; a single entry is played
#         """
#         if self.playlist_entry:
#             return self.playlist_entry.as_dict()
#         elif self.single_entry:
#             return self.single_entry.as_dict()
#         else:
#             return None


#     @hybrid_property
#     def show(self):
#         """
#         Retrieves show information based on the related schedule. If no schedule
#         is available (e.g. when the engine is in a fallback state), then the default
#         show properties from `AuraConfig` are returned.
#         """
#         show_info = {}

#         if self.schedule:
#             show_info["name"] = self.schedule.show_name
#             show_info["type"] = self.schedule.type
#             show_info["host"] = self.schedule.show_hosts
#         elif self.fallback_type == 4:
#             show_info["name"] = config.get("fallback_show_name")
#             show_info["type"] = config.get("fallback_show_type")
#             show_info["host"] = config.get("fallback_show_host")
        
#         return show_info


#     @staticmethod
#     def select_one(id):
#         """
#         Select one specific track-service item by ID. 
#         """
#         DB.session.commit() # Required since independend session is used.
#         track = DB.session.query(TrackService).filter(TrackService.id == id).first()
#         return track


#     @staticmethod
#     def select_current():
#         """
#         Selects the currently playing track.
#         """
#         now = datetime.datetime.now()
#         DB.session.commit() # Required since independend session is used.
#         track = DB.session.query(TrackService).\
#             filter(TrackService.track_start <= str(now)).\
#             order_by(TrackService.track_start.desc()).first()
#         return track


#     @staticmethod
#     def select_last_hours(n):
#         """
#         Selects the tracks playing in the past (`n`) hours.
#         """
#         last_hours = datetime.datetime.today() - datetime.timedelta(hours=n)
#         DB.session.commit() # Required since independend session is used.
#         tracks = DB.session.query(TrackService).filter(TrackService.track_start >= str(last_hours)).all()
#         for track in tracks:
#             track = TrackService.select_one(track.id)
#         return tracks


#     @staticmethod
#     def select_by_day(day):
#         """
#         Select the track-service items for a day.
#         """
#         day_plus_one = day + datetime.timedelta(days=1)
#         DB.session.commit() # Required since independend session is used.
#         tracks = DB.session.query(TrackService).\
#             filter(TrackService.track_start >= str(day), TrackService.track_start < str(day_plus_one)).\
#             order_by(TrackService.track_start.desc()).all()
        
#         res = []
#         for item in tracks:
#             if item.track: res.append(item)
#         return res
    

#     @staticmethod
#     def select_by_range(from_day, to_day):
#         """
#         Selects the track-service items for a day range.
#         """
#         DB.session.commit()
#         tracks = DB.session.query(TrackService).filter(TrackService.track_start >= str(from_day),
#                                                        TrackService.track_start < str(to_day)).all()
#         return tracks
    

#     def __str__(self):
#         """
#         Convert to String.
#         """
#         return "TrackID: #%s [track_start: %s, artificial_playlist_entry_id: %s]" % (str(self.id), str(self.track_start), str(self.artificial_playlist_entry_id))



# class SingleEntry(DB.Model, AuraDatabaseModel):
#     """
#     An entry played in case of e.g. a local fallback or custom programming without a playlist nor schedule.
#     """
#     __tablename__ = 'single_entry'

#     # Primary keys
#     id = Column(Integer, primary_key=True)
    
#     # Relationships
#     trackservice_id = Column(Integer) #, ForeignKey("trackservice.id"))
#     meta_data_id = Column(Integer) #, ForeignKey("trackservice.id"))

#     trackservice = relationship("TrackService", uselist=False, back_populates="single_entry")
#     meta_data = relationship("SingleEntryMetaData", uselist=False, back_populates="entry")

#     # Data
#     uri = Column(String(1024))
#     duration = Column(BigInteger)
#     source = Column(String(1024))
#     entry_start = Column(DateTime)

#     queue_state = None # Assigned when entry is about to be queued
#     channel = None # Assigned when entry is actually played
#     status = None # Assigned when state changes


#     @hybrid_property
#     def entry_end(self):
#         return self.entry_start + datetime.timedelta(seconds=self.duration)

#     @hybrid_property
#     def start_unix(self):
#         return time.mktime(self.entry_start.timetuple())

#     @hybrid_property
#     def end_unix(self):
#         return time.mktime(self.entry_start.timetuple()) + self.duration

#     @hybrid_property
#     def volume(self):
#         return 100

#     @hybrid_property
#     def type(self):
#         return EngineUtil.get_channel_type(self.uri)


#     def as_dict(self):
#         """
#         Returns the entry as a dictionary for serialization.
#         """
#         if self.meta_data:
#             return {
#                 "duration": self.duration,
#                 "artist": self.meta_data.artist,
#                 "album": self.meta_data.album,
#                 "title": self.meta_data.title
#             }
#         return None


#     def __str__(self):
#         """
#         String representation of the object.
#         """
#         time_start = SimpleUtil.fmt_time(self.start_unix)
#         time_end = SimpleUtil.fmt_time(self.end_unix)
#         track = self.source[-25:]
#         return "SingleEntry #%s [%s - %s | %ssec | Source: ...%s]" % (str(self.id), time_start, time_end, self.duration, track)



# class SingleEntryMetaData(DB.Model, AuraDatabaseModel):
#     """
#     Metadata for a autonomous entry such as the artist and track name.
#     """
#     __tablename__ = "single_entry_metadata"

#     id = Column(Integer, primary_key=True)
#     single_entry_id = Column(Integer, ForeignKey("single_entry.id"))

#     artist = Column(String(256))
#     title = Column(String(256))
#     album = Column(String(256))

#     entry = relationship("SingleEntry", uselist=False, back_populates="meta_data")

#     @staticmethod
#     def select_metadata_for_entry(single_entry_id):
#         return DB.session.query(SingleEntry).filter(SingleEntryMetaData.id == single_entry_id).first()





#
#   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'
    #
    # # primary and foreign keys
    # playlist_id = Column(Integer, ForeignKey("playlist.playlist_id"), primary_key=True, nullable=False, autoincrement=True)
    # entry_num = Column(Integer, primary_key=True, nullable=False, autoincrement=False)
    #
    # uri = Column(String(1024))
    #
    # source = ""
    # cleansource = ""
    # cleanprotocol = ""
    # type = None
    # fadeintimer = None
    # fadeouttimer = None
    # switchtimer = None
    #
    # meta_data = relationship("PlaylistEntryMetaData", primaryjoin="and_(PlaylistEntry.playlist_id==PlaylistEntryMetaData.playlist_id, PlaylistEntry.entry_num==PlaylistEntryMetaData.entry_num)", lazy="joined")
    #
    # # normal constructor
    # def __init__(self, **kwargs):
    #     super(PlaylistEntry, self).__init__(**kwargs)
    #     self.calc_unix_times()
    #     self.define_clean_source()
    #
    # # constructor like - called from sqlalchemy
    # @orm.reconstructor
    # def reconstructor(self):
    #     self.calc_unix_times()
    #     self.define_clean_source()
    #     self.set_entry_type()
    #
    # def define_clean_source(self):
    #     if self.uri is None:
    #         return None
    #
    #     if self.uri.startswith("http"):
    #         self.cleanprotocol = self.uri[:7]
    #         self.cleansource = self.uri
    #
    #     elif self.uri.startswith("linein"):
    #         self.cleanprotocol = self.uri[:9]
    #         self.cleansource = self.uri[9:]
    #
    #     elif self.uri.startswith("pool") or self.uri.startswith("file") or self.uri.startswith("live"):
    #         self.cleanprotocol = self.uri[:7]
    #         self.cleansource = self.uri[7:]
    #
    #     elif self.uri.startswith("playlist"):
    #         self.cleanprotocol = self.uri[:11]
    #         self.cleansource = self.uri[11:]
    #
    #     else:
    #         self.logger.error("Unknown source protocol")
    #
    # def set_entry_type(self):
    #     if self.uri.startswith("http"):
    #         self.type = ScheduleEntryType.HTTP
    #     if self.uri.startswith("pool") or self.uri.startswith("playlist") or self.uri.startswith("file"):
    #         self.type = ScheduleEntryType.FILESYSTEM
    #     if self.uri.startswith("live") or self.uri.startswith("linein"):
    #         if self.cleansource == "0":
    #             self.type = ScheduleEntryType.LIVE_0
    #         elif self.cleansource == "1":
    #             self.type = ScheduleEntryType.LIVE_1
    #         elif self.cleansource == "2":
    #             self.type = ScheduleEntryType.LIVE_2
    #         elif self.cleansource == "3":
    #             self.type = ScheduleEntryType.LIVE_3
    #         elif self.cleansource == "4":
    #             self.type = ScheduleEntryType.LIVE_4




    # def calc_unix_times(self):
    #     if self.entry_start is not None:
    #         self.entry_start_unix = time.mktime(self.entry_start.timetuple())
    #
    #
    #
    # # ------------------------------------------------------------------------------------------ #
    # @staticmethod
    # def select_all():
    #     # fetching all entries
    #     all_entries = DB.session.query(Playlist).filter(Playlist.fallback_type == 0).order_by(Playlist.entry_start).all()
    #
    #     cnt = 0
    #     for entry in all_entries:
    #         entry.programme_index = cnt
    #         cnt = cnt + 1
    #
    #     return all_entries
    #
    # @staticmethod
    # def select_act_programme(include_act_playing = True):
    #     # fetching all from today to ..
    #     today = datetime.date.today()
    #     all_entries = DB.session.query(Playlist).filter(Playlist.entry_start >= today, Playlist.fallback_type == 0).order_by(Playlist.entry_start).all()
    #
    #     cnt = 0
    #     for entry in all_entries:
    #         entry.programme_index = cnt
    #         cnt = cnt + 1
    #
    #     return all_entries
    #
    # # ------------------------------------------------------------------------------------------ #