broadcasts.py

#
#  engine
#
#  Playout Daemon for autoradio project
#
#
#  Copyright (C) 2017-2018 Gottfried Gaisbauer <gottfried.gaisbauer@servus.at>
#
#  This file is part of engine.
#
#  engine is free software: you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation, either version 3 of the License, or
#  any later version.
#
#  engine 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 General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with engine. If not, see <http://www.gnu.org/licenses/>.
#

import sys
import time
import logging
import datetime

from sqlalchemy import orm, func, Boolean, Column, DateTime, Integer, String, ForeignKey, ForeignKeyConstraint
from sqlalchemy.orm import relationship
from sqlalchemy.sql.expression import false, true
from libraries.database.database import DB
from libraries.enum.auraenumerations import ScheduleEntryType


class AuraDatabaseModel:
    logger = None

    def __init__(self):
        self.logger = logging.getLogger("AuraEngine")

    def store(self, add=False, commit=False):
        if add:
            DB.session.add(self)
        if commit:
            DB.session.commit()

    def delete(self, commit=False):
        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):
        manualschedule = Schedule()
        manualschedule.schedule_id = 0
        manualschedule.show_name = "Manual Show"

#        self.logger.debug("Recreating Database...")
        DB.drop_all()
#        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!")

        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_id = Column(Integer, primary_key=True, autoincrement=False)
    show_id = Column(Integer) # well, in fact not needed..

    schedule_start = Column(DateTime) # can be null due to manual entries
    schedule_end = Column(DateTime) # can be null due to manual entries
    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)
    timeslot_fallback_id = Column(Integer)
    show_fallback_id = Column(Integer)
    station_fallback_id = Column(Integer)

    @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

    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


# ------------------------------------------------------------------------------------------ #
class ScheduleEntry(DB.Model, AuraDatabaseModel):
    """
    One schedule can have multiple entries
    """
    __tablename__ = 'schedule_entry'

    # primary and foreign keys
    playlist_id = Column(Integer, primary_key=True, nullable=False, autoincrement=False)
    entry_num = Column(Integer, primary_key=True, nullable=False, autoincrement=False)
    schedule_id = Column(Integer, ForeignKey("schedule.schedule_id"))

    entry_start = Column(DateTime)
    source = Column(String(256))
    volume = Column(Integer, default=100)
    fallback_type = Column(Integer, default=0)
    cleansource = ""
    cleanprotocol = ""
    entry_start_unix = 0
    programme_index = -1
    type = None

    schedule = relationship("Schedule", foreign_keys=[schedule_id], lazy="joined")

    # normal constructor
    def __init__(self, **kwargs):
        super(ScheduleEntry, 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.set_entry_type()

    def define_clean_source(self):
        if self.source.startswith("http"):
            self.cleanprotocol = self.source[:7]
            self.cleansource = self.source

        elif self.source.startswith("linein"):
            self.cleanprotocol = self.source[:9]
            self.cleansource = self.source[9:]

        elif self.source.startswith("pool") or self.source.startswith("file") or self.source.startswith("live"):
            self.cleanprotocol = self.source[:7]
            self.cleansource = self.source[7:]

        elif self.source.startswith("playlist"):
            self.cleanprotocol = self.source[:11]
            self.cleansource = self.source[11:]

        else:
            self.logger.error("Unknown source protocol")

    def calc_unix_times(self):
        if self.entry_start is not None:
            self.entry_start_unix = time.mktime(self.entry_start.timetuple())

    def set_entry_type(self):
        if self.source.startswith("http"):
            self.type = ScheduleEntryType.STREAM
        if self.source.startswith("pool") or self.source.startswith("playlist") or self.source.startswith("file"):
            self.type = ScheduleEntryType.FILESYSTEM
        if self.source.startswith("live") or self.source.startswith("linein"):
            self.type = ScheduleEntryType.LIVE

    # ------------------------------------------------------------------------------------------ #
    @staticmethod
    def select_all():
        # fetching all entries
        all_entries = DB.session.query(ScheduleEntry).filter(ScheduleEntry.fallback_type == 0).order_by(ScheduleEntry.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(ScheduleEntry).filter(ScheduleEntry.entry_start >= today, ScheduleEntry.fallback_type == 0).order_by(ScheduleEntry.entry_start).all()

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



        return all_entries

    # ------------------------------------------------------------------------------------------ #
    @staticmethod
    def truncate():
        all_entries = DB.session.query(ScheduleEntry).filter().order_by(ScheduleEntry.entry_start).all()

        for a in all_entries:
            a.delete()
        DB.session.commit()

    # ------------------------------------------------------------------------------------------ #
    @staticmethod
    def select_next_manual_entry_num():

        max_manual_entry_num = DB.session.query(func.max(ScheduleEntry.entry_num)).filter(ScheduleEntry.schedule_id == 0).first()

        if max_manual_entry_num[0] is None:
            return 0
        else:
            return int(max_manual_entry_num[0])+1

    # ------------------------------------------------------------------------------------------ #
    @staticmethod
    def upcoming(datefrom=datetime.datetime.now()):
        upcomingtracks = DB.session.query(ScheduleEntry).filter(ScheduleEntry.start > datefrom).all()
        return upcomingtracks

    # ------------------------------------------------------------------------------------------ #
    @staticmethod
    def select_one(playlist_id, entry_num):
        return DB.session.query(ScheduleEntry).filter(ScheduleEntry.playlist_id == playlist_id, ScheduleEntry.entry_num == entry_num).first()

    # ------------------------------------------------------------------------------------------ #
    @staticmethod
    def select_playlist(playlist_id):
        return DB.session.query(ScheduleEntry).filter(ScheduleEntry.playlist_id == playlist_id).all()

    def getChannel(self):
        if self.type == self.type.FILESYSTEM:
            return "fs"

        if self.type == self.type.LIVE:
            return "aura_linein_"+self.cleansource # .cleanprotocol[8]

        if self.type == self.type.STREAM:
            return "http"


    # ------------------------------------------------------------------------------------------ #
    def __str__(self):
        return "ScheduleID: #" + str(self.schedule_id) + " Showname: " + self.schedule.show_name + " starts @ " + str(self.entry_start) + " and plays " + self.source


# ------------------------------------------------------------------------------------------ #
class TrackService(DB.Model, AuraDatabaseModel):
    __tablename__ = 'trackservice'

    trackservice_id = Column(Integer, primary_key=True, autoincrement=True)
    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 = 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.playlist_id==ScheduleEntry.playlist_id, TrackService.entry_num==ScheduleEntry.entry_num)", lazy="joined")

    @staticmethod
    # ------------------------------------------------------------------------------------------ #
    def select_one(trackservice_id):
        return DB.session.query(TrackService).filter(TrackService.trackservice_id == trackservice_id).first()

    @staticmethod
    # ------------------------------------------------------------------------------------------ #
    def select_by_day(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):
        tracks = DB.session.query(TrackService).filter(TrackService.start >= str(from_day),
                                                       TrackService.start < str(to_day)).all()
        return tracks

    # ------------------------------------------------------------------------------------------ #
    def __str__(self):
        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()

#AuraDatabaseModel.recreate_db(systemexit=True)