Example #1
0
def get_updated_albums_dict(sid):
    global updated_album_ids
    if not sid in updated_album_ids:
        return []

    previous_newest_album = cache.get_station(sid, "newest_album")
    if not previous_newest_album:
        cache.set_station(sid, "newest_album", timestamp())
    else:
        newest_albums = db.c.fetch_list(
            "SELECT album_id FROM r4_albums JOIN r4_album_sid USING (album_id) WHERE sid = %s AND album_added_on > %s",
            (sid, previous_newest_album))
        for album_id in newest_albums:
            updated_album_ids[sid][album_id] = True
        cache.set_station(sid, "newest_album", timestamp())
    album_diff = []
    for album_id in updated_album_ids[sid]:
        album = Album.load_from_id_sid(album_id, sid)
        album.solve_cool_lowest(sid)
        tmp = album.to_dict_full()
        # Remove user-related stuff since this gets stuffed straight down the pipe
        tmp.pop('rating_user', None)
        tmp.pop('fave', None)
        album_diff.append(tmp)
    return album_diff
Example #2
0
	def post(self):
		if self.get_argument("date_start"):
			self.date_start = time.mktime(self.get_argument("date_start").timetuple())
		else:
			self.date_start = (timestamp() - (7 * 86400) + 1)
		if self.get_argument("date_end"):
			self.date_end = time.mktime(self.get_argument("date_end").timetuple())
		else:
			self.date_end = timestamp()
		if self.date_start >= self.date_end:
			raise APIException("invalid_argument", text="Start date cannot be after end date.")
		timespan = self.date_end - self.date_start
		if timespan <= (86400 * 2):
			sql = "SELECT (lc_time - (lc_time %% 3600)) AS lc_time, ROUND(CAST(AVG(lc_guests) AS NUMERIC), 1) AS lc_listeners FROM r4_listener_counts WHERE lc_time > %s AND lc_time < %s AND sid = %s GROUP BY (lc_time - (lc_time %% 3600)) ORDER BY lc_time"
			dateformat = "%Y-%m-%d %H:00"
		elif timespan <= (86400 * 7):
			sql = "SELECT (lc_time - (lc_time %% (3600 * 6))) AS lc_time, ROUND(CAST(AVG(lc_guests) AS NUMERIC), 1) AS lc_listeners FROM r4_listener_counts WHERE lc_time > %s AND lc_time < %s AND sid = %s GROUP BY (lc_time - (lc_time %% (3600 * 6))) ORDER BY lc_time"
			dateformat = "%Y-%m-%d %H:00"
		elif timespan <= (86400 * 30):
			sql = "SELECT (lc_time - (lc_time %% 86400)) AS lc_time, ROUND(CAST(AVG(lc_guests) AS NUMERIC), 1) AS lc_listeners FROM r4_listener_counts WHERE lc_time > %s AND lc_time < %s AND sid = %s GROUP BY (lc_time - (lc_time %% 86400)) ORDER BY lc_time"
			dateformat = "%Y-%m-%d"
		else:
			sql = "SELECT (lc_time - (lc_time %% (86400 * 7))) AS lc_time, ROUND(CAST(AVG(lc_guests) AS NUMERIC), 1) AS lc_listeners FROM r4_listener_counts WHERE lc_time > %s AND lc_time < %s AND sid = %s GROUP BY (lc_time - (lc_time %% (86400 * 7))) ORDER BY lc_time"
			dateformat = "%Y-%m-%d"
		res = {}
		config.station_ids = (1, 2, 3, 4, 5)
		for sid in config.station_ids:
			res[sid] = db.c.fetch_all(sql, (self.date_start, self.date_end, sid))
			for row in res[sid]:
				dt = datetime.datetime.fromtimestamp(row['lc_time'])
				row['lc_time'] = dt.strftime(dateformat)
		self.append(self.return_name, res)
Example #3
0
def advance_station(sid):
    db.c.start_transaction()
    try:
        log.debug("advance", "Advancing station %s." % sid)
        start_time = timestamp()
        # If we need some emergency elections here
        if len(upnext[sid]) == 0:
            manage_next(sid)

        while upnext[sid][0].used or len(upnext[sid][0].songs) == 0:
            log.warn("advance", "Event ID %s was already used or has zero songs.  Deleting." % upnext[sid][0].id)
            upnext[sid][0].delete()
            upnext[sid].pop(0)
            if len(upnext[sid]) == 0:
                manage_next(sid)

        start_time = timestamp()
        upnext[sid][0].prepare_event()
        db.c.commit()

        log.debug("advance", "upnext[0] preparation time: %.6f" % (timestamp() - start_time,))
        log.info("advance", "Next song: %s" % get_advancing_file(sid))

        tornado.ioloop.IOLoop.instance().add_timeout(datetime.timedelta(milliseconds=150), lambda: post_process(sid))
    except:
        db.c.rollback()
        raise
Example #4
0
	def _start_cooldown_db(self, sid, cool_time):
		if config.has_station(sid, "cooldown_enable_for_categories") and not config.get_station(sid, "cooldown_enable_for_categories"):
			return

		cool_end = int(cool_time + timestamp())
		log.debug("cooldown", "Group ID %s Station ID %s cool_time period: %s" % (self.id, sid, cool_time))
		# Make sure to update both the if and else SQL statements if doing any updates
		if db.c.allows_join_on_update:
			db.c.update("UPDATE r4_song_sid SET song_cool = TRUE, song_cool_end = %s "
						"FROM r4_song_group "
						"WHERE r4_song_sid.song_id = r4_song_group.song_id AND r4_song_group.group_id = %s "
							"AND r4_song_sid.sid = %s AND r4_song_sid.song_exists = TRUE AND r4_song_sid.song_cool_end <= %s ",
						(cool_end, self.id, sid, cool_end))
			request_only_end = cool_end + 300
			db.c.update("UPDATE r4_song_sid SET song_request_only = TRUE, song_request_only_end = %s "
						"FROM r4_song_group "
						"WHERE r4_song_sid.song_id = r4_song_group.song_id AND r4_song_group.group_id = %s "
							"AND r4_song_sid.sid = %s AND r4_song_sid.song_exists = TRUE AND r4_song_sid.song_cool_end <= %s "
							"AND song_request_only_end IS NOT NULL",
						(request_only_end, self.id, sid, cool_end))
		else:
			song_ids = db.c.fetch_list(
				"SELECT song_id "
				"FROM r4_song_group JOIN r4_song_sid USING (song_id) "
				"WHERE r4_song_group.group_id = %s AND r4_song_sid.sid = %s AND r4_song_sid.song_exists = TRUE AND r4_song_sid.song_cool_end < %s",
				(self.id, sid, timestamp() - cool_time))
			for song_id in song_ids:
				db.c.update("UPDATE r4_song_sid SET song_cool = TRUE, song_cool_end = %s WHERE song_id = %s AND sid = %s", (cool_end, song_id, sid))
Example #5
0
	def update(self):
		handler = APIHandler(websocket=True)
		handler.locale = self.locale
		handler.request = FakeRequestObject({}, self.request.cookies)
		handler.sid = self.sid
		handler.user = self.user
		handler.return_name = "sync_result"
		try:
			startclock = timestamp()
			handler.prepare_standalone()

			if not cache.get_station(self.sid, "backend_ok"):
				raise APIException("station_offline")

			self.refresh_user()
			api_requests.info.attach_info_to_request(handler, live_voting=True)
			if self.user.is_dj():
				api_requests.info.attach_dj_info_to_request(handler)
			handler.append("user", self.user.to_private_dict())
			handler.append("api_info", { "exectime": timestamp() - startclock, "time": round(timestamp()) })
		except Exception as e:
			if handler:
				handler.write_error(500, exc_info=sys.exc_info(), no_finish=True)
			log.exception("websocket", "Exception during update.", e)
		finally:
			if handler:
				self.write_message(handler._output) 	#pylint: disable=W0212
Example #6
0
	def post(self):
		if self.get_argument("date_start"):
			self.date_start = time.mktime(self.get_argument("date_start").timetuple())
		else:
			self.date_start = (timestamp() - (7 * 86400) + 1)
		if self.get_argument("date_end"):
			self.date_end = time.mktime(self.get_argument("date_end").timetuple())
		else:
			self.date_end = timestamp()
		sql = ("SELECT aggr_time AS lc_time, ROUND(CAST(AVG(lc_guests) AS NUMERIC), 1) AS lc_listeners "
				"FROM ( "
					"SELECT (((lc_time %% 86400) / 14400) * 14400) + (((lc_time %% (86400 * 7)) / 86400) * 86400) AS aggr_time, lc_guests "
						"FROM r4_listener_counts "
						"WHERE lc_time > %s AND lc_time < %s AND sid = %s "
				") AS lc_listeners "
				"GROUP BY lc_time ORDER BY lc_time "
			)
		res = {}
		config.station_ids = (1, 2, 3, 4, 5)
		for sid in config.station_ids:
			res[sid] = db.c.fetch_all(sql, (self.date_start, self.date_end, sid))
			for row in res[sid]:
				dt = datetime.datetime.fromtimestamp(row['lc_time'])
				row['lc_time'] = dt.strftime("%a %H:%M")
		self.append(self.return_name, res)
Example #7
0
def _update_inactive():
	f = open("%s/r4_inactive_check" % tempfile.gettempdir(), 'w')
	f.write(str(int(timestamp())))
	f.close()
	time_threshold = timestamp() - (86400 * 30)
	db.c.update("UPDATE phpbb_users SET radio_inactive = TRUE "
				"WHERE radio_inactive = FALSE AND radio_last_active < %s",
				(time_threshold,))
Example #8
0
 def __init__(self, service_url, ua=UA):
     """Initialize & call webservice."""
     srv = service_url[8:20]
     last = WEBQuery.T[srv] if srv in WEBQuery.T else 0.0
     wait = 0 if timestamp() - last > THROTTLING else THROTTLING
     sleep(wait)
     self.url = service_url
     self.data = webservice.query(service_url, ua)
     WEBQuery.T[srv] = timestamp()
Example #9
0
def manage_next(sid):
    # pylint: disable=W0612
    max_sched_id, max_elec_id, num_elections, max_future_time = _get_schedule_stats(sid)
    # pylint: enable=W0612
    now_producer = get_producer_at_time(sid, timestamp())
    next_producer = get_producer_at_time(sid, max_future_time)
    nextnext_producer_start = db.c.fetch_var(
        "SELECT sched_start FROM r4_schedule WHERE sid = %s AND sched_used = FALSE AND sched_start > %s AND sched_timed = TRUE",
        (sid, max_future_time),
    )
    time_to_future_producer = None
    if nextnext_producer_start:
        time_to_future_producer = nextnext_producer_start - max_future_time
    else:
        time_to_future_producer = 86400
    while len(upnext[sid]) < min(now_producer.plan_ahead_limit, next_producer.plan_ahead_limit):
        target_length = None
        if time < 20:
            log.debug("timing", "SID %s <20 seconds to upnext event, not using timing." % sid)
        if time_to_future_producer < 40:
            target_length = time_to_future_producer
            next_producer = rainwave.events.shortest_election.ShortestElectionProducer(sid)
            log.debug("timing", "SID %s <40 seconds to upnext event, using shortest elections." % sid)
        elif time_to_future_producer < (playlist.get_average_song_length(sid) * 1.3):
            target_length = time_to_future_producer
            log.debug("timing", "SID %s close to event, timing to %s seconds long." % (sid, target_length))
        elif time_to_future_producer < (playlist.get_average_song_length(sid) * 2.2):
            target_length = playlist.get_average_song_length(sid)
            log.debug("timing", "SID %s has an upcoming event, timing to %s seconds long." % (sid, target_length))
        next_event = next_producer.load_next_event(target_length, max_elec_id)
        if not next_event:
            log.info(
                "manage_next",
                "Producer ID %s type %s did not produce an event." % (next_producer.id, next_producer.type),
            )
            next_producer = election.ElectionProducer(sid)
            next_event = next_producer.load_next_event(target_length, max_elec_id)
        upnext[sid].append(next_event)
        if next_event.is_election:
            num_elections += 1
        if next_event.is_election and next_event.id > max_elec_id:
            max_elec_id = next_event.id
        max_future_time += upnext[sid][-1].length()
        time_to_future_producer -= upnext[sid][-1].length()
        next_producer = get_producer_at_time(sid, max_future_time)

    future_time = None
    if current[sid].start:
        future_time = current[sid].start + current[sid].length()
    else:
        future_time = int(timestamp() + current[sid].length())
    for evt in upnext[sid]:
        evt.start = future_time
        future_time += evt.length()
        if evt.is_election:
            evt.update_vote_counts()
Example #10
0
	def write_output(self):
		if hasattr(self, "_output"):
			if hasattr(self, "_startclock"):
				exectime = timestamp() - self._startclock
			else:
				exectime = -1
			if exectime > 0.5:
				log.warn("long_request", "%s took %s to execute!" % (self.url, exectime))
			self.append("api_info", { "exectime": exectime, "time": round(timestamp()) })
			self.write(tornado.escape.json_encode(self._output))
Example #11
0
	def write_output(self):
		if hasattr(self, "_output"):
			if hasattr(self, "_startclock"):
				exectime = timestamp() - self._startclock
			else:
				exectime = -1
			if exectime > 0.5:
				log.warn("long_request", "%s took %s to execute!" % (self.url, exectime))
			self.append("api_info", { "exectime": exectime, "time": round(timestamp()) })
			self.write(json.dumps(self._output, ensure_ascii=False))
Example #12
0
	def should_vote_throttle(self):
		if not self.votes_by_key in votes_by:
			return 0

		vote_limit = 3
		# log.debug("vote_throttle", "%s - %s - %s" % (vote_limit, votes_by[self.votes_by_key], (timestamp() < (last_vote_by[self.votes_by_key] + vote_once_every_seconds))))
		if (votes_by[self.votes_by_key] >= vote_limit) and (timestamp() < (last_vote_by[self.votes_by_key] + vote_once_every_seconds)):
			# log.debug("vote_throttle", (last_vote_by[self.votes_by_key] + vote_once_every_seconds) - timestamp())
			return (last_vote_by[self.votes_by_key] + vote_once_every_seconds) - timestamp()
		return 0
Example #13
0
def time_transform(standard_time):
    separator = str(standard_time)[4:5]
    if separator is '/':
        time = datetime.strptime(standard_time, '%Y/%m/%d %H:%M:%S')
        return time.timestamp()
    elif separator is '-':
        time = datetime.strptime(standard_time, '%Y-%m-%d %H:%M:%S')
        return time.timestamp()
    else:
        print('Wrong input format')
Example #14
0
def warm_cooled_albums(sid):
    if sid == 0:
        return
    global updated_album_ids
    album_list = db.c.fetch_list(
        "SELECT album_id FROM r4_album_sid WHERE sid = %s AND album_cool_lowest <= %s AND album_cool = TRUE",
        (sid, timestamp()))
    for album_id in album_list:
        updated_album_ids[sid][album_id] = True
    db.c.update(
        "UPDATE r4_album_sid SET album_cool = FALSE WHERE sid = %s AND album_cool_lowest <= %s AND album_cool = TRUE",
        (sid, timestamp()))
Example #15
0
	def post(self):
		self.append(self.return_name,
			db.c.fetch_all("SELECT sched_type as type, sched_id AS id, sched_name AS name, sched_start AS start, sched_end AS end, sched_url AS url, sid, ROUND((sched_end - sched_start) / 60) AS sched_length_minutes, username "
						"FROM r4_schedule LEFT JOIN phpbb_users ON (sched_dj_user_id = user_id)  "
						"WHERE sched_used = FALSE AND sched_start >= %s ORDER BY sched_start",
						(timestamp(),)))

		self.append(self.return_name + "_past",
			db.c.fetch_all("SELECT sched_type as type, sched_id AS id, sched_name AS name, sched_start AS start, sched_end AS end, sched_url AS url, sid, ROUND((sched_end - sched_start) / 60) AS sched_length_minutes, username "
						"FROM r4_schedule LEFT JOIN phpbb_users ON (sched_dj_user_id = user_id)  "
						"WHERE sched_type != 'PVPElectionProducer' AND sched_start > %s AND sched_start < %s ORDER BY sched_start DESC",
						(timestamp() - (86400 * 26), timestamp())))
Example #16
0
def build_message_html(time, source, target, message, specialuser, usercolor, emoteset, emotes, displayname):
	if source.lower() == config['notifyuser']:
		return '<div class="notification line" data-timestamp="%d">%s</div>' % (time.timestamp(), escape(message))

	if message[:4].lower() in (".me ", "/me "):
		is_action = True
		message = message[4:]
	else:
		is_action = False

	ret = []
	ret.append('<div class="line" data-timestamp="%d">' % time.timestamp())
	if 'staff' in specialuser:
		ret.append('<span class="badge staff"></span> ')
	if 'admin' in specialuser:
		ret.append('<span class="badge admin"></span> ')
	if "#" + source.lower() == target.lower():
		ret.append('<span class="badge broadcaster"></span> ')
	if 'mod' in specialuser:
		ret.append('<span class="badge mod"></span> ')
	if 'turbo' in specialuser:
		ret.append('<span class="badge turbo"></span> ')
	if 'subscriber' in specialuser:
		ret.append('<span class="badge subscriber"></span> ')
	ret.append('<span class="nick"')
	if usercolor:
		ret.append(' style="color:%s"' % escape(usercolor))
	ret.append('>%s</span>' % escape(displayname or (yield from get_display_name(source))))

	if is_action:
		ret.append(' <span class="action"')
		if usercolor:
			ret.append(' style="color:%s"' % escape(usercolor))
		ret.append('>')
	else:
		ret.append(": ")

	if 'cleared' in specialuser:
		ret.append('<span class="deleted">&lt;message deleted&gt;</span>')
		# Use escape() rather than urlize() so as not to have live spam links
		# either for users to accidentally click, or for Google to see
		ret.append('<span class="message cleared">%s</span>' % escape(message))
	elif emotes is not None:
		messagehtml = format_message_explicit_emotes(message, emotes)
		ret.append('<span class="message">%s</span>' % messagehtml)
	else:
		messagehtml = format_message(message, (yield from get_filtered_emotes(emoteset)))
		ret.append('<span class="message">%s</span>' % messagehtml)

	if is_action:
		ret.append('</span>')
	ret.append('</div>')
	return ''.join(ret)
Example #17
0
def wait_for(callback, value, timeout=EFSConnection.DEFAULT_WAIT_TIMEOUT_SECONDS):
    """
     Helper method to wait for desired value returned by callback method
    """
    wait_start = timestamp()
    while True:
        if callback() != value:
            if timeout != 0 and (timestamp() - wait_start > timeout):
                raise RuntimeError('Wait timeout exceeded (' + str(timeout) + ' sec)')
            else:
                sleep(5)
            continue
        break
Example #18
0
def set_song_rating(sid, song_id, user_id, rating=None, fave=None):
    db.c.start_transaction()
    try:
        existing_rating = db.c.fetch_row(
            "SELECT song_rating_user, song_fave FROM r4_song_ratings WHERE song_id = %s AND user_id = %s",
            (song_id, user_id),
        )
        count = db.c.fetch_var("SELECT COUNT(*) FROM r4_song_ratings WHERE user_id = %s", (user_id,))
        if not existing_rating:
            count += 1
        rank = db.c.fetch_var("SELECT COUNT(*) FROM phpbb_users WHERE radio_totalratings > %s", (count,))
        if existing_rating:
            if not rating:
                rating = existing_rating["song_rating_user"]
            if not fave:
                fave = existing_rating["song_fave"]
            db.c.update(
                "UPDATE r4_song_ratings "
                "SET song_rating_user = %s, song_fave = %s, song_rated_at = %s, song_rated_at_rank = %s, song_rated_at_count = %s "
                "WHERE user_id = %s AND song_id = %s",
                (rating, fave, timestamp(), rank, count, user_id, song_id),
            )
            db.c.update(
                "UPDATE phpbb_users SET radio_totalmindchange = radio_totalmindchange + 1, radio_inactive = FALSE, radio_last_active = %s WHERE user_id = %s",
                (timestamp(), user_id),
            )
        else:
            if not rating:
                rating = None
            if not fave:
                fave = None
            db.c.update(
                "INSERT INTO r4_song_ratings "
                "(song_rating_user, song_fave, song_rated_at, song_rated_at_rank, song_rated_at_count, user_id, song_id) "
                "VALUES (%s, %s, %s, %s, %s, %s, %s)",
                (rating, fave, timestamp(), rank, count, user_id, song_id),
            )

        db.c.update(
            "UPDATE phpbb_users SET radio_totalratings = %s, radio_inactive = FALSE, radio_last_active = %s WHERE user_id = %s",
            (count, timestamp(), user_id),
        )

        albums = update_album_ratings(sid, song_id, user_id)
        db.c.commit()
        cache.set_song_rating(song_id, user_id, {"rating_user": rating, "fave": fave})
        return albums
    except:
        db.c.rollback()
        raise
Example #19
0
def pair_device(receiver, args):
	# get all current devices
	known_devices = [dev.number for dev in receiver]

	from logitech_receiver import base, hidpp10, status, notifications
	receiver.status = status.ReceiverStatus(receiver, lambda *args, **kwargs: None)

	# check if it's necessary to set the notification flags
	old_notification_flags = hidpp10.get_notification_flags(receiver) or 0
	if not (old_notification_flags & hidpp10.NOTIFICATION_FLAG.wireless):
		hidpp10.set_notification_flags(receiver, old_notification_flags | hidpp10.NOTIFICATION_FLAG.wireless)

	class HandleWithNotificationHook(int):
		def notifications_hook(self, n):
			assert n
			if n.devnumber == 0xFF:
				notifications.process(receiver, n)
			elif n.sub_id == 0x41 and n.address == 0x04:
				if n.devnumber not in known_devices:
					receiver.status.new_device = receiver[n.devnumber]

	timeout = 20  # seconds
	receiver.handle = HandleWithNotificationHook(receiver.handle)
	receiver.set_lock(False, timeout=timeout)
	print ("Pairing: turn your new device on (timing out in", timeout, "seconds).")

	# the lock-open notification may come slightly later, wait for it a bit
	from time import time as timestamp
	pairing_start = timestamp()
	patience = 5  # seconds

	while receiver.status.lock_open or timestamp() - pairing_start < patience:
		n = base.read(receiver.handle)
		if n:
			n = base.make_notification(*n)
			if n:
				receiver.handle.notifications_hook(n)

	if not (old_notification_flags & hidpp10.NOTIFICATION_FLAG.wireless):
		# only clear the flags if they weren't set before, otherwise a
		# concurrently running Solaar app might stop working properly
		hidpp10.set_notification_flags(receiver, old_notification_flags)

	if receiver.status.new_device:
		dev = receiver.status.new_device
		print ("Paired device %d: %s [%s:%s:%s]" % (dev.number, dev.name, dev.wpid, dev.codename, dev.serial))
	else:
		error = receiver.status[status.KEYS.ERROR] or 'no device detected?'
		_fail(error)
Example #20
0
def _trim(sid):
	# Deletes any events in the schedule and elections tables that are old, according to the config
	current_time = int(timestamp())
	db.c.update("DELETE FROM r4_schedule WHERE sched_start_actual <= %s", (current_time - config.get("trim_event_age"),))
	db.c.update("DELETE FROM r4_elections WHERE elec_start_actual <= %s", (current_time - config.get("trim_election_age"),))
	max_history_id = db.c.fetch_var("SELECT MAX(songhist_id) FROM r4_song_history")
	db.c.update("DELETE FROM r4_song_history WHERE songhist_id <= %s AND sid = %s", (max_history_id - config.get("trim_history_length"), sid))
Example #21
0
 def old_row_to_user_id(name, uuid=None, time=None):
     if not name:
         return None
     try:
         return user_ids.get_or_create(name, add_uuid_dashes(uuid), int(time.timestamp()) if time else 0)
     except NoSuchMojangUser:
         log.warning("Can't find user with name '{0}'".format(name))
Example #22
0
 def _start_cooldown_db(self, sid, cool_time):
     cool_end = int(cool_time + timestamp())
     if db.c.allows_join_on_update:
         db.c.update(
             "UPDATE r4_song_sid "
             "SET song_cool = TRUE, song_cool_end = %s "
             "FROM r4_songs "
             "WHERE r4_song_sid.song_id = r4_songs.song_id AND album_id = %s AND sid = %s AND song_cool_end <= %s ",
             (cool_end, self.id, sid, cool_end),
         )
         request_only_end = cool_end + config.get_station(sid, "cooldown_request_only_period")
         db.c.update(
             "UPDATE r4_song_sid "
             "SET song_request_only = TRUE, song_request_only_end = %s "
             "FROM r4_songs "
             "WHERE r4_song_sid.song_id = r4_songs.song_id AND album_id = %s AND sid = %s AND song_cool_end <= %s "
             "AND song_request_only_end IS NOT NULL",
             (request_only_end, self.id, sid, cool_end),
         )
     else:
         songs = db.c.fetch_list(
             "SELECT song_id FROM r4_song_sid JOIN r4_songs USING (song_id) WHERE album_id = %s AND sid = %s AND song_exists = TRUE AND song_cool_end < %s",
             (self.id, sid, cool_end),
         )
         for song_id in songs:
             db.c.update(
                 "UPDATE r4_song_sid SET song_cool = TRUE, song_cool_end = %s WHERE song_id = %s AND song_cool_end < %s AND sid = %s",
                 (cool_end, song_id, cool_end, sid),
             )
Example #23
0
def get_next(sid):
	line = cache.get_station(sid, "request_line")
	if not line:
		return None
	song = None
	for pos in range(0, len(line)):
		if not line[pos]:
			pass  # ?!?!
		elif 'skip' in line[pos] and line[pos]['skip']:
			log.debug("request", "Passing on user %s since they're marked as skippable." % line[pos]['username'])
		elif not line[pos]['song_id']:
			log.debug("request", "Passing on user %s since they have no valid first song." % line[pos]['username'])
		else:
			entry = line.pop(pos)
			song = playlist.Song.load_from_id(entry['song_id'], sid)
			log.debug("request", "Fulfilling %s's request for %s." % (entry['username'], song.filename))
			song.data['elec_request_user_id'] = entry['user_id']
			song.data['elec_request_username'] = entry['username']

			u = User(entry['user_id'])
			db.c.update("DELETE FROM r4_request_store WHERE user_id = %s AND song_id = %s", (u.id, entry['song_id']))
			u.remove_from_request_line()
			request_count = db.c.fetch_var("SELECT COUNT(*) FROM r4_request_history WHERE user_id = %s", (u.id,)) + 1
			db.c.update("DELETE FROM r4_request_store WHERE song_id = %s AND user_id = %s", (song.id, u.id))
			db.c.update("INSERT INTO r4_request_history (user_id, song_id, request_wait_time, request_line_size, request_at_count, sid) "
						"VALUES (%s, %s, %s, %s, %s, %s)",
						(u.id, song.id, timestamp() - entry['line_wait_start'], len(line), request_count, sid))
			db.c.update("UPDATE phpbb_users SET radio_totalrequests = %s WHERE user_id = %s", (request_count, u.id))
			song.update_request_count(sid)
			break

	return song
Example #24
0
def dj_heartbeat_check():
	# Don't do this in testing environments
	if config.get("developer_mode"):
		return
	for sid in config.station_ids:
		if cache.get_station(sid, "backend_paused_playing"):
			hb = cache.get_station(sid, "dj_heartbeat")
			hbs = cache.get_station(sid, "dj_heartbeat_start")
			if not hbs or ((timestamp() - hbs) <= 10):
				pass
			elif not hb or ((timestamp() - hb) >= 15):
				log.warn("dj_heartbeat", "DJ heart attack - resetting station to normal.")
				cache.set_station(sid, "backend_paused", False)
				cache.set_station(sid, "backend_paused_playing", False)
				liquidsoap.kick_dj(sid)
				liquidsoap.skip(sid)
Example #25
0
    def signInterest(self, interest, keyName=None, wireFormat=None):
        # Adds the nonce and timestamp here, because there is no
        # 'makeCommandInterest' call for this yet
        nonceValue = bytearray(8)
        for i in range(8):
            nonceValue[i] = self.random.randint(0,0xff)
        timestampValue = bytearray(8)
        ts = int(timestamp()*1000)
        for i in range(8):
            byte = ts & 0xff
            timestampValue[-(i+1)] = byte
            ts = ts >> 8

        if wireFormat is None:
            wireFormat = WireFormat.getDefaultWireFormat()

        s = Sha256HmacSignature()
        s.getKeyLocator().setType(KeyLocatorType.KEYNAME)
        s.getKeyLocator().setKeyName(keyName)

        interestName = interest.getName()
        interestName.append(nonceValue).append(timestampValue)
        interestName.append(wireFormat.encodeSignatureInfo(s))
        interestName.append(Name.Component())

        encoding = interest.wireEncode(wireFormat)
        signer = hmac.new(self.key, encoding.toSignedBuffer(), sha256)

        s.setSignature(Blob(signer.digest()))
        interest.setName(interestName.getPrefix(-1).append(
            wireFormat.encodeSignatureValue(s)))
Example #26
0
def _process_line(line, sid):
	new_line = []
	# user_positions has user_id as a key and position as the value, this is cached for quick lookups by API requests
	# so users know where they are in line
	user_positions = {}
	t = int(timestamp())
	albums_with_requests = []
	position = 1
	# For each person
	for row in line:
		add_to_line = False
		u = User(row['user_id'])
		row['song_id'] = None
		# If their time is up, remove them and don't add them to the new line
		if row['line_expiry_tune_in'] and row['line_expiry_tune_in'] <= t:
			log.debug("request_line", "%s: Removed user ID %s from line for tune in timeout, expiry time %s current time %s" % (sid, u.id, row['line_expiry_tune_in'], t))
			u.remove_from_request_line()
		else:
			tuned_in_sid = db.c.fetch_var("SELECT sid FROM r4_listeners WHERE user_id = %s AND sid = %s AND listener_purge = FALSE", (u.id, sid))
			tuned_in = True if tuned_in_sid == sid else False
			if tuned_in:
				# Get their top song ID
				song_id = u.get_top_request_song_id(sid)
				# If they have no song and their line expiry has arrived, boot 'em
				if not song_id and row['line_expiry_election'] and (row['line_expiry_election'] <= t):
					log.debug("request_line", "%s: Removed user ID %s from line for election timeout, expiry time %s current time %s" % (sid, u.id, row['line_expiry_election'], t))
					u.remove_from_request_line()
					# Give them more chances if they still have requests
					# They'll get added to the line of whatever station they're tuned in to (if any!)
					if u.has_requests():
						u.put_in_request_line(u.get_tuned_in_sid())
				# If they have no song, start the expiry countdown
				elif not song_id and not row['line_expiry_election']:
					row['line_expiry_election'] = t + 900
					db.c.update("UPDATE r4_request_line SET line_expiry_election = %s WHERE user_id = %s", ((t + 900), row['user_id']))
					add_to_line = True
				# Keep 'em in line
				else:
					if song_id:
						albums_with_requests.append(db.c.fetch_var("SELECT album_id FROM r4_songs WHERE song_id = %s", (song_id,)))
					row['song_id'] = song_id
					add_to_line = True
			elif not row['line_expiry_tune_in'] or row['line_expiry_tune_in'] == 0:
				db.c.update("UPDATE r4_request_line SET line_expiry_tune_in = %s WHERE user_id = %s", ((t + 600), row['user_id']))
				add_to_line = True
			else:
				add_to_line = True
		if add_to_line:
			new_line.append(row)
			user_positions[u.id] = position
			position = position + 1

	cache.set_station(sid, "request_line", new_line, True)
	cache.set_station(sid, "request_user_positions", user_positions, True)

	db.c.update("UPDATE r4_album_sid SET album_requests_pending = NULL WHERE album_requests_pending = TRUE AND sid = %s", (sid,))
	for album_id in albums_with_requests:
		db.c.update("UPDATE r4_album_sid SET album_requests_pending = TRUE WHERE album_id = %s AND sid = %s", (album_id, sid))

	return new_line
Example #27
0
def _get_schedule_stats(sid):
    global upnext
    global current

    max_sched_id = 0
    max_elec_id = None
    end_time = int(timestamp())
    if sid in current and current[sid]:
        max_sched_id = current[sid].id
        if current[sid].start_actual:
            end_time = current[sid].start_actual + current[sid].length()
        else:
            end_time += current[sid].length()
        if current[sid].is_election:
            max_elec_id = current[sid].id
    num_elections = 0

    if sid in upnext:
        for e in upnext[sid]:
            if e.is_election:
                num_elections += 1
                if e.id > max_elec_id:
                    max_elec_id = e.id
            elif not e.is_election and e.id > max_sched_id:
                max_sched_id = e.id
            end_time += e.length()

    if not max_elec_id:
        max_elec_id = db.c.fetch_var(
            "SELECT elec_id FROM r4_elections WHERE elec_used = TRUE ORDER BY elec_id DESC LIMIT 1"
        )

    return (max_sched_id, max_elec_id, num_elections, end_time)
Example #28
0
def get_producer_at_time(sid, at_time):
    to_ret = None
    local_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(at_time))
    time_ahead = int((at_time - timestamp()) / 60)
    sched_id = db.c.fetch_var(
        "SELECT sched_id "
        "FROM r4_schedule "
        "WHERE sid = %s AND sched_start <= %s AND sched_end > %s "
        "ORDER BY sched_id DESC "
        "LIMIT 1",
        (sid, at_time + 20, at_time),
    )
    try:
        to_ret = events.event.BaseProducer.load_producer_by_id(sched_id)
        if to_ret:
            to_ret.start_producer()
    except Exception as e:
        log.warn("get_producer", "Failed to obtain producer at time %s (%sm ahead)." % (local_time, time_ahead))
        log.exception(
            "get_producer",
            "Failed to get an appropriate producer at time %s  (%sm ahead)." % (local_time, time_ahead),
            e,
        )
    if not to_ret:
        log.debug(
            "get_producer", "No producer at time %s  (%sm ahead), defaulting to election." % (local_time, time_ahead)
        )
        return election.ElectionProducer(sid)
    if not to_ret.has_next_event():
        log.warn("get_producer", "Producer ID %s (type %s, %s) has no events." % (to_ret.id, to_ret.type, to_ret.name))
        return election.ElectionProducer(sid)
    return to_ret
Example #29
0
    async def _msg_handler(self, msg_data : Dict):
        now = datetime.now()
        if (now - self.user.state.connection_time).seconds < TIME_BEFORE_TALK:
            return self.send_json(type='wait',date=timestamp()*1000)

        if self._check_flood(msg_data['msg']):
            return
        # user object instance renders both the output sound and output text
        output_msg, wav = await self.user.render_message(msg_data["msg"], msg_data.get("lang", "fr"))
        # estimating the end of the current voice render, to rate limit
        calc_sendend = max(self.sendend, now) + timedelta(seconds=len(wav) * 8 / 6000000)
        synth = calc_sendend < now + timedelta(seconds=2.5)
        if synth:
            self.sendend = calc_sendend

        output_msg = escape(output_msg)

        # send to the backlog
        info = self.channel_obj.log_to_backlog(self.user.user_id, output_msg)
        if not self.user.state.is_shadowbanned:
            if "notext" in msg_data and self.raw_cookie in SOUND_BROADCASTER_COOKIES:
                self.channel_obj.broadcast(type="audio_broadcast", userid=self.user.user_id,
                                           binary_payload=wav if synth else None)
            else:
                # broadcast message and rendered audio to all clients in the channel
                self.channel_obj.broadcast(type='msg', userid=self.user.user_id,
                                           msg=output_msg, date=info['date'],
                                           binary_payload=wav if synth else None)
        else: # we just send the message to the current client
            self.send_json(type='msg', userid=self.user.user_id,
                           msg=output_msg, date=info['date'])
            if synth:
                self.send_binary(wav)
Example #30
0
    async def _attack_handler(self, msg_data : Dict):
        # cleaning up none values in case of fuckups
        msg_data = {key: value for key, value in msg_data.items() if value is not None}

        adversary_id, adversary = self.channel_obj.get_user_by_name(msg_data.get("target",
                                                                                 self.user.poke_params.pokename),
                                                                    msg_data.get("order", 1) - 1)
        now = datetime.now()

        # checking if the target user is found, and if the current user has waited long enough to attack
        if adversary is None:
            self.send_json(type='attack', event='invalid')
        elif (now - self.user.state.last_attack < timedelta(seconds=ATTACK_RESTING_TIME)):
            self.send_json(type='attack', event='invalid')
        else:
            self.channel_obj.broadcast(type='attack', date=timestamp() * 1000,
                                       event='attack',
                                       attacker_id=self.user.user_id,
                                       defender_id=adversary_id)

            combat_sim = CombatSimulator()
            combat_sim.run_attack(self.user, adversary, self.channel_obj)
            self.channel_obj.broadcast(type='attack', date=timestamp() * 1000,
                                       event='dice',
                                       attacker_dice=combat_sim.atk_dice,
                                       defender_dice=combat_sim.def_dice,
                                       attacker_bonus=combat_sim.atk_bonus,
                                       defender_bonus=combat_sim.def_bonus,
                                       attacker_id=self.user.user_id,
                                       defender_id=adversary_id)

            if combat_sim.affected_users: # there are users affected by some effects
                for user, effect in combat_sim.affected_users:
                    self.channel_obj.broadcast(type='attack', date=timestamp() * 1000,
                                               event='effect',
                                               tag=effect.TAG if hasattr(effect, "TAG") else None,
                                               target_id=user.user_id,
                                               effect=effect.name,
                                               timeout=effect.timeout)
            else: # list is empty, no one was attacked
                self.channel_obj.broadcast(type='attack', date=timestamp() * 1000,
                                           event='nothing')

            # combat_sim uses the last attack time to compute the bonus,
            # so it must be updated after the running the attack.
            self.user.state.last_attack = now
Example #31
0
    def upload_theme(self, ndthemepack: str):
        data = json.dumps({
            "themePackUrl": ndthemepack,
            "timestamp": int(timestamp() * 1000)
        })

        response = requests.post(
            f"{self.api}/x{self.comId}/s/community/settings",
            data=data,
            headers=headers.Headers(data=data).headers)
        if response.status_code == 200: return response.status_code
        else: return json.loads(response.text)
Example #32
0
def test_message_sendlater_invalid_token():
    # Test if AccessError is raised when given invalid token
    clear_v1()
    user = auth_register_v2('*****@*****.**', 'password1234', 'Harry', 'Lurr')
    channel = channels_create_v2(user['token'], 'HARRYS CHANNEL', True)

    time = datetime.now().replace(microsecond=0) + timedelta(0, 3)
    time_sent = time.timestamp()

    with pytest.raises(AccessError):
        message_sendlater_v1(-2382732, channel['channel_id'], 'Poopoo',
                             time_sent)
Example #33
0
    def update(self):
        # Overwrite this value since who knows how long we've spent idling
        self._startclock = timestamp()

        if not cache.get_station(self.sid, "backend_ok"):
            raise APIException("station_offline")

        self.user.refresh(self.sid)
        if "requests_paused" in self.user.data:
            del self.user.data["requests_paused"]
        api_requests.info.attach_info_to_request(self)
        self.finish()
    def find_best_feature(self, x):
        """
            Find the best feature for a median split value.

            :param DataFrame x: Samples data frame.

            :return: The best feature name.
        """
        start_time = timestamp()
        features = [f for f in x.columns if f not in ["time", "event"]]
        if not self.fix_tree_features:
            # features = list(np.random.permutation(features))[:self.max_features]
            features = list(self.rs.permutation(features))[:self.max_features]
        information_gains = [self.logrank(x, feature) for feature in features]
        highest_ig = max(information_gains)
        end_time = timestamp()
        # self.print("    Find best feature time: {}".format(end_time - start_time))
        if highest_ig == 0:
            return None
        else:
            return features[information_gains.index(highest_ig)]
Example #35
0
 def setNickname(self, nickname, community_id, uid):
     result = requests.post(self.api + "x" + str(community_id) +
                            "/s/user-profile/" + uid + "?sid=" + self.sid,
                            data=json.dumps({
                                "nickname":
                                nickname,
                                "timestamp": (int(timestamp() * 1000))
                            }),
                            headers={
                                'Content-Type': 'application/json'
                            }).json()
     return result
Example #36
0
def _trim(sid):
    # Deletes any events in the schedule and elections tables that are old, according to the config
    current_time = int(timestamp())
    db.c.update("DELETE FROM r4_schedule WHERE sched_start_actual <= %s",
                (current_time - config.get("trim_event_age"), ))
    db.c.update("DELETE FROM r4_elections WHERE elec_start_actual <= %s",
                (current_time - config.get("trim_election_age"), ))
    max_history_id = db.c.fetch_var(
        "SELECT MAX(songhist_id) FROM r4_song_history")
    db.c.update(
        "DELETE FROM r4_song_history WHERE songhist_id <= %s AND sid = %s",
        (max_history_id - config.get("trim_history_length"), sid))
Example #37
0
 def solve_cool_lowest(self, sid):
     self.data['cool_lowest'] = db.c.fetch_var(
         "SELECT MIN(song_cool_end) FROM r4_song_sid JOIN r4_songs USING (song_id) WHERE album_id = %s AND sid = %s AND song_exists = TRUE",
         (self.id, sid))
     if self.data['cool_lowest'] > timestamp():
         self.data['cool'] = True
     else:
         self.data['cool'] = False
     db.c.update(
         "UPDATE r4_album_sid SET album_cool_lowest = %s, album_cool = %s WHERE album_id = %s AND sid = %s",
         (self.data['cool_lowest'], self.data['cool'], self.id, sid))
     return self.data['cool_lowest']
Example #38
0
    def set_privacy_status(self, isAnonymous: bool = False, getNotifications: bool = False):
        data = {"timestamp": int(timestamp() * 1000)}

        if not isAnonymous: data["privacyMode"] = 1
        if isAnonymous: data["privacyMode"] = 2
        if not getNotifications: data["notificationStatus"] = 2
        if getNotifications: data["privacyMode"] = 1

        data = json.dumps(data)
        response = requests.post(f"{self.api}/g/s/account/visit-settings", headers=headers.Headers(data=data).headers, data=data)
        if response.status_code != 200: return json.loads(response.text)
        else: return response.status_code
Example #39
0
 async def trigger(self, loultstate):
     for channel in loultstate.chans.values():
         for user in channel.users.values():
             if random.randint(1, 10) == 1:
                 effect = self.BienDowmiwEffect()
                 channel.broadcast(type='attack',
                                   date=timestamp() * 1000,
                                   event='effect',
                                   tag=effect.TAG,
                                   target_id=user.user_id,
                                   effect=effect.name,
                                   timeout=effect.timeout)
Example #40
0
 def __setitem__(self, key, value):
     """Write to cache."""
     try:
         s = self._sh.open(self.filepath)
         s[key] = {'value': value, 'hits': 0, 'timestamp': timestamp()}
         self._keys.append(key)
         status = True
     except:
         status = False
     finally:
         s.close()
     return status
Example #41
0
def inactive_checking():
    last_time = 0
    if os.path.isfile("%s/r4_inactive_check" % tempfile.gettempdir()):
        f = open("%s/r4_inactive_check" % tempfile.gettempdir())
        t = f.read()
        f.close()
        try:
            last_time = int(t)
        except Exception:
            pass
    if (not last_time) or (last_time < (timestamp() - 86400)):
        _update_inactive()
Example #42
0
	def invite_to_chat(self, community_id, thread_id: str, userId: [str, list]):
		if isinstance(userId, str): userIds = [userId]
		elif isinstance(userId, list): userIds = userId
		else: raise exceptions.WrongType(type(userId))

		data = json.dumps({
			"uids": userIds,
			"timestamp": int(timestamp() * 1000)
		})

		response = requests.post(f"{self.api}/x{community_id}/s/chat/thread/{thread_id}/member/invite?sid="+self.sid, headers={'Content-Type': 'application/json'}, data=data)
		return response.json()
Example #43
0
 async def trigger(self, loultstate):
     for channel in loultstate.chans.values():
         users_lists = list(channel.users.values())
         random.shuffle(users_lists)
         for user_receiver, user_giver in zip(channel.users.values(),
                                              users_lists):
             user_receiver.state.add_effect(
                 VoiceCloneEffect(user_giver.voice_params))
         channel.broadcast(type="notification",
                           event_type="voice_shuffle",
                           date=timestamp() * 1000,
                           msg="Les voix des pokémons ont été mélangées!")
Example #44
0
def record_sizes():
    global _prefix

    gc.collect()
    linecache.clearcache()

    try:
        d = os.path.join(tempfile.gettempdir(),
                         "rw_memory_%s_%s.json" % (_prefix, int(timestamp())))
        meliae.scanner.dump_all_objects(d)
    except:
        pass
Example #45
0
    def delete_message(self, chatId: str, messageId: str, asStaff: bool = False, reason: str = None):
        data = {
            "adminOpName": 102,
            "adminOpNote": {"content": reason},
            "timestamp": int(timestamp() * 1000)
        }

        data = json.dumps(data)
        if not asStaff: response = requests.delete(f"{self.api}/g/s/chat/thread/{chatId}/message/{messageId}", headers=headers.Headers().headers)
        else: response = requests.post(f"{self.api}/g/s/chat/thread/{chatId}/message/{messageId}/admin", headers=headers.Headers(data=data).headers, data=data)
        if response.status_code != 200: return json.loads(response.text)
        else: return response.status_code
Example #46
0
def test_datetime_unixts(module, unixts, tz):
    v = module.Datetime(unixts=unixts, tz=tz)
    today = date.today()
    now = datetime.now() if tz is None else datetime.now(UTC).astimezone(tz)
    assert v(today) == datetime.combine(today, time(tzinfo=tz))
    assert v(now) == now
    assert v.clone() == v
    assert pickle.loads(pickle.dumps(v)) == v

    if unixts:
        ts = timestamp()
        assert (
            v(ts) == datetime.fromtimestamp(ts)
            if tz is None
            else datetime.fromtimestamp(ts, UTC).astimezone(tz)
        )
    else:
        with pytest.raises(exc.InvalidTypeError) as info:
            v(timestamp())
        assert info.value.expected == datetime
        assert info.value.actual == float
Example #47
0
 def is_eqmktopen(self, time):
     second = (time.timestamp() + 8 * 3600) % 86400
     if time.weekday() < 5:
         if second < 3600:
             return True
         if second >= 33600 and second < 43200:
             return True
         if second >= 46800 and second < 59700:
             return True
         if second >= 62100:
             return True
     return False
Example #48
0
 def adminDeleteMessage(self, mid, community_id, thread_id):
     result = requests.post(
         f"{self.api}x{community_id}/s/chat/thread/{thread_id}/message/{mid}/admin?sid="
         + self.sid,
         data=json.dumps({
             "adminOpName": 102,
             "timestamp": (int(timestamp() * 1000))
         }),
         headers={
             'Content-Type': 'application/json'
         }).json()
     return result
def test_message_sendlater_invalid_channel_id():
    # Test if InputError is raised when given invalid channel id
    clear_v1_http()
    user = auth_register_v2_http('*****@*****.**', 'password123', 'Terry',
                                 'Wills').json()
    channels_create_v2_http(user['token'], 'TERRYS CHANNEL', True).json()

    time = datetime.now().replace(microsecond=0) + timedelta(0, 3)
    time_sent = time.timestamp()

    message_sendlater_v1_http(user['token'], -1, 'anyone here?',
                              time_sent).status_code == 400
Example #50
0
    async def change_module(self, module: str, isEnabled: bool):
        if module.lower() == "chat": mod = "module.chat.enabled"
        elif module.lower() == "livechat":
            mod = "module.chat.avChat.videoEnabled"
        elif module.lower() == "screeningroom":
            mod = "module.chat.avChat.screeningRoomEnabled"
        elif module.lower() == "publicchats":
            mod = "module.chat.publicChat.enabled"
        elif module.lower() == "posts":
            mod = "module.post.enabled"
        elif module.lower() == "ranking":
            mod = "module.ranking.enabled"
        elif module.lower() == "leaderboards":
            mod = "module.ranking.leaderboardEnabled"
        elif module.lower() == "featured":
            mod = "module.featured.enabled"
        elif module.lower() == "featuredposts":
            mod = "module.featured.postEnabled"
        elif module.lower() == "featuredusers":
            mod = "module.featured.memberEnabled"
        elif module.lower() == "featuredchats":
            mod = "module.featured.publicChatRoomEnabled"
        elif module.lower() == "sharedfolder":
            mod = "module.sharedFolder.enabled"
        elif module.lower() == "influencer":
            mod = "module.influencer.enabled"
        elif module.lower() == "catalog":
            mod = "module.catalog.enabled"
        elif module.lower() == "externalcontent":
            mod = "module.externalContent.enabled"
        elif module.lower() == "topiccategories":
            mod = "module.topicCategories.enabled"
        else:
            raise exceptions.SpecifyType(module.lower())

        data = json.dumps({
            "path": mod,
            "value": isEnabled,
            "timestamp": int(timestamp() * 1000)
        })

        if self.comId is None: raise exceptions.CommunityNeeded()

        async with self.session.post(
                f"{self.api}/x{self.comId}/s/community/configuration",
                headers=self.parse_headers(data=data),
                data=data) as response:
            if response.status != 200:
                return exceptions.CheckException(
                    json.loads(await response.text()))
            else:
                return response.status
Example #51
0
    def client_config(self):
        data = json.dumps({
            "deviceID": self.device_id,
            "bundleID": "com.narvii.amino.master",
            "clientType": 100,
            "timezone": -timezone // 1000,
            "systemPushEnabled": True,
            "locale": locale()[0],
            "timestamp": int(timestamp() * 1000)
        })

        response = requests.post(f"{self.api}/g/s/device", headers=headers.Headers(data=data).headers, data=data)
        if response.status_code == 200: self.configured = True
Example #52
0
    def change_sidepanel_color(self, color: str):
        data = json.dumps({
            "path": "appearance.leftSidePanel.style.iconColor",
            "value": color,
            "timestamp": int(timestamp() * 1000)
        })

        response = requests.post(
            f"{self.api}/x{self.comId}/s/community/configuration",
            headers=headers.Headers(data=data).headers,
            data=data)
        if response.status_code == 200: return response.status_code
        else: return json.loads(response.text)
Example #53
0
def test_message_sendlater_message_too_long():
    # InputError raised if message given is more than 1000 characters
    clear_v1()
    user = auth_register_v2('*****@*****.**', 'pasword24323132', 'Tinker',
                            'Bell')
    channel = channels_create_v2(user['token'], 'Insert Title Here', True)

    time = datetime.now().replace(microsecond=0) + timedelta(0, 3)
    time_sent = time.timestamp()

    with pytest.raises(InputError):
        message_sendlater_v1(user['token'], channel['channel_id'], 'L' * 1001,
                             time_sent)
Example #54
0
    def upload_theme(self, themePackUrl: str):
        data = json.dumps({
            "themePackUrl": themePackUrl,
            "timestamp": int(timestamp() * 1000)
        })

        if self.comId is None: raise exceptions.CommunityNeeded
        response = requests.post(
            f"{self.api}/x{self.comId}/s/community/settings",
            data=data,
            headers=headers.Headers(data=data).headers)
        if response.status_code == 200: return response.status_code
        else: return json.loads(response.text)
Example #55
0
            def ajax(request, user, user_id):

                if user is not False:
                    return JsonResponse(
                        {
                            'version': '0.1.0',
                            'status': 302,
                            'user': {
                                'id':
                                user.user_id,
                                'name':
                                user.full_name,
                                'registered':
                                timestamp(user.date_registered.utctimetuple()),
                                'last_login':
                                timestamp(user.last_login.utctimetuple()),
                                'email': {
                                    'primary': user.email_primary,
                                    'secondary': user.email_secondary or None
                                },
                                'role':
                                user.role.name if user.role else None,
                                'schedule':
                                None
                            }
                        },
                        status=302)

                return JsonResponse(
                    {
                        'version':
                        '0.1.0',
                        'status':
                        404,
                        'reason':
                        'User with ID %s does not exist or is invalid' %
                        user_id
                    },
                    status=404)
Example #56
0
    def __exit__(self, exc_type, exc_val, exc_tb):
        T1 = timestamp() - self.T0
        stats = self.stats.get(self.name, [0, 0.0])
        stats[0] += 1
        stats[1] += T1
        self.stats[self.name] = stats

        msg = self.EXIT_MESSAGE.format(name=self.name,
                                       elapsed=T1,
                                       count=stats[0],
                                       total=stats[1],
                                       avg=stats[1] / stats[0])
        self.logger.info(msg)
Example #57
0
    async def reinitialise(self):
        """Re-instantiates the polls saved to file"""
        decoded = {}
        with open(self._dest) as file:
            decoded = json.loads(file.read())

        for key, val in decoded.items():
            if val["timestamp"] + val["duration"] <= timestamp():
                continue

            restored_poll = await Poll.restore(val)
            if restored_poll is not None:
                self[key] = restored_poll
Example #58
0
def add_user_tags():
    logger.debug("function add_user_tags __enter__")
    #print (request.args)
    if request.method == 'POST' or request.method == 'GET':
        user_tags = UserTags()
        user_tags.user_id = request.values.get("user_id", '',
                                               type=str)  # user_id
        user_tags.tags = request.values.get("tags", '',
                                            type=str).replace(',', '|')  # tags
        user_tags.create_time = timestamp()
        user_tags.update_time = timestamp()

        ut = UserTags.query.filter(
            UserTags.user_id == user_tags.user_id).first()
        if ut:
            logger.info("user exist, update. user_id: " + str(ut.user_id))
            ut.user_id = user_tags.user_id
            ut.tags = user_tags.tags.replace(',', '|')
            ut.update_time = user_tags.update_time
            if 'user_tags_update_times' in session:
                session['user_tags_update_times'] = session[
                    'user_tags_update_times'] + 1
            else:
                session['user_tags_update_times'] = 1
            ut.modify_times = session['user_tags_update_times']
            #ut.session.add()
            db.session.commit()
            end = '{"code": 1000, "msg": "%s" }' % ("用户标签已更新。")
            return json.loads(json.dumps(end))
        else:
            db.session.add(user_tags)
            db.session.commit()
            logger.info("user tags added, user_id: " + str(user_tags.user_id))
            end = '{"code": 1000, "msg": "%s" }' % ("用户标签已添加。")
            return json.loads(json.dumps(end))
    logger.warning("error, GET/POST wrong. ")
    end = '{"code": 1003, "msg": "%s" }' % ("请求方法不正确。")
    retstr = json.loads(json.dumps(end.encode('utf-8')))
    return retstr
Example #59
0
    def add_influencer(self, userId: str, monthlyFee: int):
        data = json.dumps({
            "monthlyFee": monthlyFee,
            "timestamp": int(timestamp() * 1000)
        })

        if self.comId is None: raise exceptions.CommunityNeeded()
        response = requests.post(
            f"{self.api}/x{self.comId}/s/influencer/{userId}",
            headers=headers.Headers(data=data).headers,
            data=data)
        if response.status_code == 200: return response.status_code
        else: return json.loads(response.text)
Example #60
0
    def change_guidelines(self, message: str):
        data = json.dumps({
            "content": message,
            "timestamp": int(timestamp() * 1000)
        })

        if self.comId is None: raise exceptions.CommunityNeeded()
        response = requests.post(
            f"{self.api}/x{self.comId}/s/community/guideline",
            headers=headers.Headers(data=data).headers,
            data=data)
        if response.status_code == 200: return response.status_code
        else: return json.loads(response.text)