def generate_listener_peak(user):
    role_host = Role.get_role('host')
    user_listener_max = 0

    shows = Show.query.join(UserShow).filter(UserShow.user == user,
                                             UserShow.role == role_host,
                                             UserShow.status == UserShow.STATUS.STREAMED,
                                             Show.end <= now()).yield_per(50)

    for show in shows:
        try:
            stats_total = Statistic.query.filter(Statistic.identifier == 'lst-total').one()
            stats = stats_total.get(start=show.begin, stop=show.end)
        except exc.NoResultFound:
            stats = None

        if stats and stats.count() > 0:
            for stat in stats:
                if stat.value > user_listener_max:
                    user_listener_max = stat.value

    if user_listener_max > 0:
        us = UserStatistic.get_userstatistic(user, 'listenerpeak')
        us.statistic.set(now(), user_listener_max)
        rfk.database.session.flush()

def now_playing():
    try:
        ret = {}
        #gather showinfos
        show = Show.get_active_show()
        if show:
            user = show.get_active_user()
            if show.end:
                end = to_timestamp(to_user_timezone(show.end))
            else:
                end = None
            ret['show'] = {'id': show.show,
                           'name': show.name,
                           'begin': to_timestamp(to_user_timezone(show.begin)),
                           'now': to_timestamp(to_user_timezone(now())),
                           'end': end,
                           'logo': show.get_logo(),
                           'type': Show.FLAGS.name(show.flags),
                           'user': {'countryball': iso_country_to_countryball(user.country)}
            }
            if show.series:
                ret['series'] = {'name': show.series.name}
            link_users = []
            for ushow in show.users:
                link_users.append(make_user_link(ushow.user))
            ret['users'] = {'links': natural_join(link_users)}

        #gather trackinfos
        track = Track.current_track()
        if track:
            ret['track'] = {'title': track.title.name,
                            'artist': track.title.artist.name,
            }

        #gather nextshow infos
        if show and show.end:
            filter_begin = show.end
        else:
            filter_begin = now()
        if request.args.get('full') == 'true':
            nextshow = Show.query.filter(Show.begin >= filter_begin).order_by(Show.begin.asc()).first();
            if nextshow:
                ret['nextshow'] = {'name': nextshow.name,
                                   'begin': to_timestamp(to_user_timezone(nextshow.begin)),
                                   'logo': nextshow.get_logo()}
                if nextshow.series:
                    ret['nextshow']['series'] = nextshow.series.name

        #get listenerinfo for disco
        listeners = Listener.get_current_listeners()
        ret['listener'] = {}
        for listener in listeners:
            ret['listener'][listener.listener] = {'listener': listener.listener,
                                                  'county': listener.country,
                                                  'countryball': iso_country_to_countryball(listener.country)}
        return jsonify({'success': True, 'data': ret})
    except Exception as e:
        raise e
        return jsonify({'success': False, 'data': unicode(e)})

def relay_sparkline(relay):
    relay = Relay.query.get(relay)
    rs = RelayStatistic.get_relaystatistic(relay, RelayStatistic.TYPE.TRAFFIC)
    start = now()-timedelta(hours=6)
    dps = []
    for dp in rs.statistic.get(start=start, stop=now()):
        dps.append((int(dp.timestamp.strftime('%s')), dp.value))
    return jsonify({'datapoints': dps})

def listeners():

    # check if current_user is logged in and if user is streaming or if user is admin
    if not current_user.is_anonymous():
        is_streaming = UserShow.query.join(User).filter(UserShow.status == UserShow.STATUS.STREAMING, UserShow.user == current_user).first()
        if is_streaming or current_user.has_permission('admin'):
            show_listener_list = True
        else:
            show_listener_list = False
    else:
        show_listener_list = False

    # get current bandwidth of all active relays
    total_bandwidth = 0
    relays = Relay.query.filter(Relay.status == Relay.STATUS.ONLINE).all()
    active_relays = len(relays)
    for relay in relays:
        total_bandwidth += relay.usage
    total_bandwidth *= 128 # convert kbit to byte

    # get all current listeners
    current_listener = Listener.get_current_listeners()

    # generate per country stats
    per_country = {}
    for listener in current_listener:
        country = listener.country
        try:
            per_country[country]['count'] += 1
        except KeyError:
            per_country[country] = {'count': 1}
            per_country[country]['ball'] = country
    per_country = sorted(per_country.iteritems(), key=lambda (k, v): v['count'], reverse=True)

    # get recent listener count to calculate a trend
    try:
        stats_total = Statistic.query.filter(Statistic.identifier == 'lst-total').one()
        stats = stats_total.get(start=now() - datetime.timedelta(minutes=2), stop=now())
    except exc.NoResultFound:
        stats = None

    if stats and stats.count() > 0:
        listener_sum = 0
        for stat in stats:
            listener_sum += stat.value
        average_listeners = listener_sum / stats.count()
    else:
        average_listeners = len(current_listener)

    return render_template('listenergraph.html', TITLE='Listeners', show_listener_list=show_listener_list,
                           listeners=current_listener, per_country=per_country, total_bandwidth=total_bandwidth,
                           active_relays=active_relays, average_listeners=average_listeners)

 def test_init_show_planned(self):
     begin = now()-timedelta(minutes=10)
     end = now()+timedelta(minutes=10)
     show = Show(begin=begin,
                 end=end,
                 name='titel',
                 description='description',
                 flags=Show.FLAGS.PLANNED)
     rfk.database.session.add(show)
     rfk.database.session.flush()
     show.add_user(self.user)
     rfk.database.session.commit()
     self.test_do_connect_valid_user()
     self.assertEqual(show, show.get_active_show())
     self.assertEqual(Show.get_active_show().flags & Show.FLAGS.PLANNED, Show.FLAGS.PLANNED)

    def check_key(key):

        try:
            apikey = ApiKey.query.filter(ApiKey.key == key).one()
        except (exc.NoResultFound, exc.MultipleResultsFound):
            raise rexc.api.KeyInvalidException()
        if apikey.flag & ApiKey.FLAGS.DISABLED:
            raise rexc.api.KeyDisabledException()
        elif not apikey.flag & ApiKey.FLAGS.FASTQUERY:
            if now() - apikey.access <= timedelta(seconds=1):
                raise rexc.api.FastQueryException(last_access=apikey.access)

        apikey.counter += 1
        apikey.access = now()
        return apikey

def login():
    form = login_form(request.form)
    if request.method == 'POST' and form.validate():
        username = form.username.data
        try:
            user = User.get_user(username=username)
            if user and user.check_password(password=form.password.data):
                user.authenticated = True
                remember = form.remember.data
                if login_user(user, remember=remember):
                    user.last_login = now()
                    loc = rfk.helper.get_location(request.remote_addr)
                    if 'country_code' in loc and loc['country_code'] is not None:
                        user.country = loc['country_code']
                    rfk.database.session.commit()
                    flash('Logged in!', 'success')
                    return redirect(request.args.get('next') or url_for('index'))
                else:
                    form.username.errors.append('There was an error while logging you in.')
                    flash('There was an error while logging you in.', 'error')
            else:
                form.username.errors.append('Invalid User or Password.')
                flash('Invalid username or password.')
        except UserNotFoundException:
            form.username.errors.append('Invalid User or Password.')
            flash('Invalid username or password.')
    return render_template('login.html', form=form, TITLE='Login')

 def end_show(self):
     """ends the Show
        raises exception if the show is planned since it doesn't need to be ended"""
     if self.flags & Show.FLAGS.PLANNED:
         raise Exception
     self.end = now()
     rfk.database.session.flush()

def show_edit(show):
    if 'begin' in request.form and \
                    'description' in request.form and \
                    'duration' in request.form and \
                    'title' in request.form:
        if int(request.form['duration']) < 30:
            return emit_error(6, 'Duration too short')
        if int(request.form['duration']) > 1440:
            return emit_error(5, 'Duration too long')
        if len(request.form['title']) < 3:
            return emit_error(4, 'Title too short')
        if len(request.form['description']) == 0:
            return emit_error(3, 'Description is empty')
        show = Show.query.get(show)
        if show is None:
            return emit_error(7, 'Whoop, invalid show!')
        if show.get_usershow(current_user) is None:
            return emit_error(8, 'Trying to edit another user\'s show, eh?!')
        begin = to_utc(datetime.fromtimestamp(int(request.form['begin'])))
        begin = begin.replace(second=0)
        if begin < now():
            return jsonify({'success': False, 'error': 'You cannot enter a past date!'})
        end = begin + timedelta(minutes=int(request.form['duration']))
        if Show.query.filter(Show.end > begin, Show.begin < end, Show.show != show.show).count() > 0:
            return emit_error(1, 'Your show collides with other shows')
        show.begin = begin
        show.end = end
        _set_show_info(show, request.form)
        rfk.database.session.commit()
    else:
        return emit_error(0, 'Wait a second, are you trying to trick me again?!')
    return jsonify({'success': True, 'data': None})

def main():
    try:
        rfk.init()
        if rfk.CONFIG.has_option('database', 'url'):
            init_db(rfk.CONFIG.get('database', 'url'))
        else:
            init_db("%s://%s:%[email protected]%s/%s" % (rfk.CONFIG.get('database', 'engine'),
                                          rfk.CONFIG.get('database', 'username'),
                                          rfk.CONFIG.get('database', 'password'),
                                          rfk.CONFIG.get('database', 'host'),
                                          rfk.CONFIG.get('database', 'database')))
        for relay in Relay.query.all():
            try:
                relay.usage = get_stats_direct(relay)
                rs = RelayStatistic.get_relaystatistic(relay, RelayStatistic.TYPE.TRAFFIC)
                if relay.usage is not None:
                    rs.statistic.set(now(), relay.usage)
                relay.status = Relay.STATUS.ONLINE
                rfk.database.session.commit()
            except urllib2.URLError as e:
                rfk.database.session.rollback()
                relay.status = Relay.STATUS.UNKNOWN
                rfk.database.session.commit()
                print "Could not reach server: {}:{} - ".format(relay.address, relay.port, str(e))
            except socket.timeout as e:
                rfk.database.session.rollback()
                relay.status = Relay.STATUS.UNKNOWN
                rfk.database.session.commit()
                print "Could not reach server: {}:{} - ".format(relay.address, relay.port, str(e))
    except Exception as e:
        print e
    finally:
        rfk.database.session.rollback()
        rfk.database.session.remove()

def login():
    form = login_form(request.form)
    if request.method == 'POST' and form.validate():
        username = form.username.data
        try:
            user = User.get_user(username=username)
            if user and user.check_password(password=form.password.data):
                user.authenticated = True
                remember = form.remember.data
                if login_user(user, remember=remember):
                    if not user.last_login:
                        flash(gettext('<strong>Tip:</strong> It appears that this is your first login, if you need any help please visit our help section by clicking <a href="/help">here</a>.'), 'info')
                    user.last_login = now()
                    loc = rfk.helper.get_location(request.remote_addr)
                    if 'country_code' in loc and loc['country_code'] is not None:
                        user.country = loc['country_code']
                    rfk.database.session.commit()
                    flash(gettext('Login successful. Welcome %s!' % user.username), 'success')
                    return redirect(request.args.get('next') or url_for('index'))
                else:
                    form.username.errors.append(gettext('There was an error while logging you in.'))
                    #flash('There was an error while logging you in.', 'error')
            else:
                form.username.errors.append(gettext('Invalid User or Password.'))
                #flash('Invalid username or password.')
        except UserNotFoundException:
            form.username.errors.append(gettext('Invalid User or Password.'))
            #flash('Invalid username or password.')
    return render_template('login.html', form=form, TITLE='Login')

 def set_offline(self):
     """sets this combination of stream and relay to offline"""
     self.status = StreamRelay.STATUS.OFFLINE
     connected_listeners = Listener.query.filter(Listener.stream_relay == self,
                                                 Listener.disconnect == None).all()
     for listener in connected_listeners:
         listener.disconnect = now()

def generate_listenerhours(user):
    role_host = Role.get_role('host')
    total_listener_hours = 0

    for usershow in UserShow.query.filter(UserShow.user == user,
                                          UserShow.role == role_host,
                                          UserShow.status == UserShow.STATUS.STREAMED).yield_per(50):

        for listener in Listener.query.filter(Listener.connect <= usershow.show.end,
                                              usershow.show.begin <= Listener.disconnect).all():
            s = listener.connect
            if s < usershow.show.begin:
                s = usershow.show.begin
            e = listener.disconnect
            if e > usershow.show.end:
                e = usershow.show.end
            listener_time = e - s
            if listener_time.total_seconds() >= 0:
                total_listener_hours += listener_time.total_seconds()/3600
            else:
                print 'something went wrong: negative listenertime isn\'t possible'

    if total_listener_hours > 0 or True:
        us = UserStatistic.get_userstatistic(user, 'listenerhours')
        us.statistic.set(now(), total_listener_hours)
        rfk.database.session.flush()

def update_global_statistics():
    try:
        stat = rfk.database.stats.Statistic.query.filter(rfk.database.stats.Statistic.identifier == 'lst-total').one()
    except sqlalchemy.orm.exc.NoResultFound:
        stat = rfk.database.stats.Statistic(name='Overall Listener', identifier='lst-total')
        rfk.database.session.add(stat)
        rfk.database.session.flush()
    stat.set(now(), rfk.database.streaming.Listener.get_total_listener())

 def end_track(self, end=None):
     """ends the track and updates length in artist/title DB"""
     if end is None:
         self.end = now()
     else:
         self.end = end
     length = self.end - self.begin
     self.title.update_length(length.total_seconds())

def now_playing():
    try:
        ret = {}
        #gather showinfos
        show = Show.get_active_show()
        if show:
            user = show.get_active_user()
            if show.end:
                end = int(to_user_timezone(show.end).strftime("%s")) * 1000
            else:
                end = None
            ret['show'] = {'id': show.show,
                           'name': show.name,
                           'begin': int(to_user_timezone(show.begin).strftime("%s")) * 1000,
                           'now': int(to_user_timezone(now()).strftime("%s")) * 1000,
                           'end': end,
                           'logo': show.get_logo(),
                           'type': Show.FLAGS.name(show.flags),
                           'user': {'countryball': iso_country_to_countryball(user.country)}
            }
            if show.series:
                ret['series'] = {'name': show.series.name}
            link_users = []
            for ushow in show.users:
                link_users.append(make_user_link(ushow.user))
            ret['users'] = {'links': natural_join(link_users)}


        #gather nextshow infos
        if show and show.end:
            filter_begin = show.end
        else:
            filter_begin = now()
        if request.args.get('full') == 'true':
            nextshow = Show.query.filter(Show.begin >= filter_begin).order_by(Show.begin.asc()).first();
            if nextshow:
                ret['nextshow'] = {'name': nextshow.name,
                                   'begin': int(to_user_timezone(nextshow.begin).strftime("%s")) * 1000,
                                   'logo': nextshow.get_logo()}
                if nextshow.series:
                    ret['nextshow']['series'] = nextshow.series.name
        return jsonify({'success': True, 'data': ret})
    except Exception as e:
        raise e
        return jsonify({'success': False, 'data': unicode(e)})

def naturaltime(dt):
    # i18n isnt working because of various fuckups
    # will fix later

    #locale = get_locale()
    #locale_name = '_'.join([locale.language, locale.territory])
    #humanize.i18n.activate(locale_name)

    return humanize.time.naturaltime(now() - dt)

 def test_transition_unplanned_planned(self):
     self.test_init_show_unplanned()
     show = Show.get_active_show()
     show.begin = show.begin - timedelta(minutes=5)
     rfk.database.session.commit()
     begin = now()-timedelta(minutes=3)
     end = now()+timedelta(minutes=10)
     show = Show(begin=begin,
                 end=end,
                 name='titel2',
                 description='description2',
                 flags=Show.FLAGS.PLANNED)
     rfk.database.session.add(show)
     rfk.database.session.flush()
     show.add_user(self.other_user)
     rfk.database.session.commit()
     self.test_do_metadata()
     self.assertEqual(Show.get_active_show(), show)

def main():
    for relay in Relay.query.all():
        try:
            relay.usage = get_stats(relay)
            rs = RelayStatistic.get_relaystatistic(relay, RelayStatistic.TYPE.TRAFFIC)
            if relay.usage is not None:
                rs.statistic.set(now(),relay.usage)
            rfk.database.session.commit()
        except urllib2.URLError:
            pass

def generate_missed_show_ratio(user):
    role_host = Role.get_role('host')
    missed_shows = 0
    total_shows = 0

    for usershow in UserShow.query.join(Show).filter(UserShow.user == user,
                                                     UserShow.role == role_host,
                                                     Show.flags == Show.FLAGS.PLANNED,
                                                     Show.end <= now()).yield_per(50):

        total_shows += 1
        if usershow.status != UserShow.STATUS.STREAMED:
            missed_shows += 1

    if total_shows > 0:
        missed_show_ratio = (float(missed_shows)/float(total_shows))*100

        us = UserStatistic.get_userstatistic(user, 'missedshowratio')
        us.statistic.set(now(), missed_show_ratio)
        rfk.database.session.flush()