def task_initial(self, grab, task):
self.request_item.title = grab.doc.select('//title').text()
for elem in grab.xpath_list('//a[not(contains(@href, "http"))]'):
if (self.result_counter >= self.total):
self.result_status = 'success'
self.info = 'All images grabbed'
self.request_item.status = self.result_status
self.request_item.info = self.info
db.session.commit()
with app.app_context():
socketio.emit('finish', 'finish', namespace='/main')
eventlet.sleep(0)
self.stop()
return
else:
if elem.get('href') not in self.urls:
self.urls.append(elem.get('href'))
yield Task('link', url=elem.get('href'))
if (self.result_counter != self.total):
self.result_status = 'error'
self.info = 'Not of all images grabbed'
else:
self.request_item.status = self.result_status
self.request_item.info = self.info
db.session.commit()
with app.app_context():
socketio.emit('finish', 'finish', namespace='/main')
eventlet.sleep(0)
self.stop()
def cycle_switches(self):
self.log.info("Emitting message: %s, %s", self.rollup_time, time.time())
with app.app_context():
exp = config.CYCLE_EXPERIMENTS[self.experiment_idx]
self.experiment_idx = (self.experiment_idx + 1) % len(config.CYCLE_EXPERIMENTS)
npts = EXPERIMENT_CONFIGS[exp]['npts']
startf, stopf = EXPERIMENT_CONFIGS[exp]['start'], EXPERIMENT_CONFIGS[exp]['stop']
msg = {
"src-guid" : "nooooooope",
"switch-matrix" :
{
"experiment-1" : exp == 1,
"experiment-2" : exp == 2,
"experiment-3" : exp == 3,
"experiment-4" : exp == 4,
},
'start-stop' : [startf, stopf],
'no-points' : npts,
}
app.config['ARBITER'].set_experiment(msg["switch-matrix"])
app.config['ARBITER'].set_num_points(npts)
app.config['ARBITER'].set_start_stop_freq(startf, stopf)
socketio.emit('config', msg, broadcast=True, namespace='/vna_interface')
def winner(picture):
user = User.query.filter_by(id=session['user-info']['id']).first()
game = user.game
if game is None:
flash('You\'re not in a game!', 'warning')
return redirect(url_for('.index'))
if game.current_player != user.id:
flash('You\'re not the current picker!', 'warning')
return redirect(url_for('.index'))
game.current_round += 1
pic = Picture.query.filter_by(id=picture).first()
playerWinner = game.users.filter_by(id=pic.user_id).first()
playerWinner.current_streak += 1
playerWinner.experience += playerWinner.current_streak
playerWinner.best_streak = max(playerWinner.current_streak,
playerWinner.best_streak)
for player in game.users:
if player != playerWinner and player != user:
player.current_streak = 0
if game.current_round <= game.rounds:
#go on to next round
game.phrase = ""
for picture in game.pictures:
picture.game_id = None
db.session.delete(picture)
users = getPlayerOrder(game)
game.current_player = users[game.current_round % len(users)].id
flash('%s was the winner!' % playerWinner.username, 'success')
socketio.emit('anything', broadcast=True)
db.session.commit()
return redirect(url_for('.index'))
def task_link(self, grab, task):
for image in grab.doc.select('//img'):
try:
if (self.result_counter >= self.total):
self.result_status = 'success'
self.info = 'All images grabbed'
self.request_item.status = self.result_status
self.request_item.info = self.info
db.session.commit()
with app.app_context():
socketio.emit('finish', 'finish', namespace='/main')
eventlet.sleep(0)
self.stop()
return
src = image.attr('src')
res = urllib.urlopen(src)
http_message = res.info()
if self.image_type != 'all' and self.image_type != http_message.type:
continue
hash = os.urandom(16).encode('hex')
filename = hash + src.split('/')[-1]
self.downloader.retrieve(src, 'app/static/images/' + filename)
self.result_counter += 1
image_item = Image(
self.request_item,
src,
filename)
db.session.add(image_item)
with app.app_context():
socketio.emit('grabed_count', self.result_counter, namespace='/main')
eventlet.sleep(0)
except Exception as e:
continue
def game(game_id):
name = session['name']
print name
if request.method == 'POST':
move = request.form['data']
sender_id = request.form['sender_id']
if game_id not in games:
return ""
if sender_id not in games[game_id].keys():
return ""
if -2 == sum(player['move'] for player in games[game_id].values() if player['move'] == -1):
games[game_id][sender_id]['move'] = move
else:
games[game_id][sender_id]['move'] = move
for player in games[game_id].values():
socketio.emit('submittedMove', {'msg': player['move']}, namespace='/game', room=player['opp_id'])
games.pop(game_id, None)
print games[game_id][sender_id]
return 'Received'
return render_template('game.html', name=name, game_id=game_id, id=session[game_id])
def postSong(url=None):
data = {
"success": False
}
if url is None:
url = request.json.get('url')
title = findTitle(url)
if title is None:
data["message"] = "Invalid URL!"
return data
else:
if "youtube" in url:
url = "//www.youtube.com/embed/" + getYoutubeId(url)
newSong = Song(url=url, title=title)
db.session.add(newSong)
try:
db.session.commit()
except:
data["message"] = "Song already in playlist!"
db.session.rollback()
return data
data = {
"success": True,
"data": {
"id": newSong.id,
"url": newSong.url,
"title": newSong.title
}
}
socketio.emit('new-song', data['data'])
return data
def create_game(cls):
#create row in game table
game = Game(game_started=True)
db.session.add(game)
db.session.commit()
#randomly passing order that will be assigned when we create scoresheets
positions = range(0, number_of_players)
random.shuffle(positions)
#create a scoresheet for each player TODO: this is currently making a game from all players in the db
players = Player.query.all()
for player in players:
p = Scoresheet(player=player.name, game_id=game.id, position=positions.pop())
db.session.add(p)
db.session.commit()
for i in range(0,number_of_rounds):
r = Round(scoresheet_id=p.id, round_number=i+1)
db.session.add(r)
db.session.commit()
# assemble data to be sent
send_data = {'logMessage': 'game started','players': game.get_players()}
socketio.emit('start_game', send_data, namespace=namespace)
#play the first round
game.play_round()
def file_failed(file):
"""
will be called whenever a File fails
:param file: the File object of the File that has failed
"""
# delete from "processes"
ProcessRepository.processes.pop(file.id)
# update status and set attributes to zero
file = db.session.query(File).filter_by(id=file.id).first()
file.status = StatusMap.failed.value
file.clear()
db.session.commit()
# check if it's necessary to start new processes
ProcessRepository.check_and_start_processes()
# notify client
socketio.emit("file_done", {
"data": {
"id": file.id,
"count_active": ProcessRepository.count_processes_active(),
"count_queued": ProcessRepository.count_processes_queued(),
"count_total": ProcessRepository.count_processes_total(),
}
})
def receive_play_card(self, card):
card = card[-1]+card[:-1]
turn_index = self.get_turn_index()
players = self.get_players()
player = players[turn_index]
player_stat = self.get_scoresheets()[turn_index].get_stats(self.round)
player_stat.played_cards += (card + ',')
# log who played what card
msg = {'message': player + " played " + card}
socketio.emit('server_message', msg, namespace=namespace)
#add it to the player's played card space
send_data = {'player': player, 'suit': card[:1], 'rank': card[1:]}
socketio.emit('card_played', send_data, namespace=namespace)
# increase the turn counter
self.cards_played_counter += 1
self.turn += 1
db.session.commit()
# if trick isn't over, get the next players card
if self.cards_played_counter % number_of_players != 0:
self.request_play_card()
# if trick is over, score the trick
else:
self.score_trick()
def emit_message(self, *args, **kwargs):
username = kwargs.get('room')
if username:
user = Player.query.filter_by(name=username)
if user.bot:
Bot(self.game)
socketio.emit(*args, **kwargs)
def rt_feed(self):
print("FEED")
feeds_collection = mongo.db.feed
now = datetime.utcnow()
from_ = now - timedelta(minutes=now.minute % 5 + app.config["FEED_REFRESH"], seconds=now.second, microseconds=now.microsecond)
feeds = feeds_collection.find()
socketio.emit("update", dumps(feeds), namespace=rt_feed_namespace)
def rt_map(self):
print("MAP")
assets_collection = mongo.db.assets
now = datetime.utcnow()
from_ = now - timedelta(minutes=now.minute % 5 + app.config["RTMAP_REFRESH"], seconds=now.second, microseconds=now.microsecond)
assets = assets_collection.find({"ipmeta.country": {"$ne": "unknown"}}, {"ipmeta.iso_code": 1, "ipmeta.city": 1, "ipmeta.country": 1, "ipmeta.geo": 1})
socketio.emit("update", dumps(assets), namespace=rt_map_namespace)
def notify_object_updated(target, ignore_classes=None):
if not ignore_classes:
ignore_classes = set()
target_class = target.__class__
target.last_updated = datetime.utcnow()
string_mapping = table_to_string_mapping[target_class]
# for attr in bidirectional_relationships.get(target_class, []):
# related_objs = getattr(target, attr)
# try:
# _related_objs = related_objs.all()
# related_objs = _related_objs
# except AttributeError:
# continue
#
# if related_objs:
# print("Updating Related objs", related_objs)
# try:
# for obj in related_objs:
# if obj.__class__ not in ignore_classes:
# ignore_classes.add(target_class)
# _notify_object_updated(obj, ignore_classes)
#
# except TypeError:
# if related_objs.__class__ not in ignore_classes:
# ignore_classes.add(target_class)
# _notify_object_updated(related_objs, ignore_classes)
socketio.emit('updated', update_msg_schema.dump({
'last_updated': target.last_updated,
'model': string_mapping,
'id': str(target.id)
}), namespace=make_namespace(string_mapping), broadcast=True)
def get_genotypes(json):
ids = extract_ids(json)
for id_subset in subset(ids, 500):
genotypes = []
for id in id_subset:
genotype = next(Genotype.query.filter(Genotype.id == id).values(
Genotype.id, Genotype.project_id, Genotype.sample_annotations_id, Genotype.locus_id,
Genotype.annotated_peaks, Genotype.reference_run_id, Genotype.flags, Genotype.comments,
Genotype.last_updated, Genotype.alleles
))
genotypes.append(genotype)
# genotypes = Genotype.query.filter(Genotype.id.in_(id_subset)).values(
# Genotype.id, Genotype.project_id, Genotype.sample_annotations_id, Genotype.locus_id,
# Genotype.annotated_peaks, Genotype.reference_run_id, Genotype.flags, Genotype.comments,
# Genotype.last_updated, Genotype.alleles
# )
res = []
for s in genotypes:
g = {
'id': s[0],
'project': s[1],
'sample_annotations': s[2],
'locus': s[3],
'annotated_peaks': s[4],
'reference_run': s[5],
'flags': s[6],
'comments': s[7],
'last_updated': s[8],
'alleles': s[9]
}
res.append(g)
genotypes_dump = schema.dumps(res, many=True)
socketio.emit('get_updated', {JSON_NAMESPACE: genotypes_dump.data}, namespace=make_namespace(JSON_NAMESPACE))
socketio.sleep()
def emit_task_success(self, message=None, callback=None):
socketio.emit(self.task, {
'task_args': self.task_args,
'status': 'success',
'id': self.task_id,
'payload': message
}, namespace=self.namespace, callback=callback)
socketio.sleep()
def notify_created(_, __, target):
target_class = target.__class__
string_mapping = table_to_string_mapping[target_class]
# print("Inserting class {} with id {}".format(string_mapping, str(target.id)))
socketio.emit('created', {
'model': string_mapping,
'id': str(target.id)
}, namespace=make_namespace(string_mapping), broadcast=True)
def emit_task_progress(self, progress, callback=None):
socketio.emit(self.task, {
'task_args': self.task_args,
'status': 'in_progress',
'id': self.task_id,
'payload': progress
}, namespace=self.namespace, callback=callback)
socketio.sleep()
def emit_task_start(self, data=None, callback=None):
socketio.emit(self.task, {
'task_args': self.task_args,
'status': 'start',
'id': self.task_id,
'payload': data
}, namespace=self.namespace, callback=callback)
socketio.sleep()
def start_helper(tc):
try:
sopen = tc.start();
flash('Trying to start the tempcontrol')
except SerialException as e:
flash('SerialException: Could not open serial connection', 'error')
socketio.emit('open_conn',{'data': tc.conn_str()})
return redirect(url_for('main.index'))
def background_thread():
count = 0
while True:
time.sleep(10)
count += 1
socketio.emit('my response',
{'data': 'Server generated event', 'count': count},
namespace='/chat')
def log(self, message):
post = ConferenceLog(conference=self, message=message)
db.session.add(post)
db.session.commit()
socketio.emit('log_message', {
'data': message,
'room': 'conference-%s' % self.id
})
def notify_locus_parameter_locked(_, __):
locus_parameter_subsets = defaultdict(list)
for target in db.session.dirty:
if isinstance(target, ProjectLocusParams):
locus_parameter_subsets[table_to_string_mapping[target.__class__]].append((target.id, target.locked))
for subset_label in locus_parameter_subsets:
locus_parameters = locus_parameter_subsets[subset_label]
socketio.emit('locked', locus_parameters, namespace=make_namespace(subset_label), broadcast=True)
def create_question():
toid = request.args.get("to", "")
if not toid == "":
question = Question(submitter_id=current_user().id, to_id=int(toid), description=request.form["description"])
db.session.add(question)
db.session.commit()
socketio.emit("question_added", "question created", room="consultants", namespace="/consultants")
return redirect("/questions/by/" + str(current_user().id))
def queuewall():
previous_images = set(os.listdir(flapp.config['QUEUE_DIR']))
previous_images = map(lambda f: flapp.config['QUEUE_DIR'] + f, previous_images)
for img in previous_images:
add_image_to_wall_q(img)
images = get_queue_wall_images()
print images
socketio.emit('images', {'images':images}, namespace = '/queue')
return render_template('queue.html')
def pickingPhase(user, game):
form = PickAWordForm(request.form)
words = getWord(adjs, 5)
picker_id = game.current_player
picker = User.query.filter_by(id=picker_id).first()
socketio.emit('anything', broadcast=True)
return render_template('pickaword.html', form=form,
isPicker=picker_id == user.id, words=words, picker=picker.username,
game_round=game.current_round)
def add_processing_files():
"""
send client information about all currently processing Files
"""
files = FileRepository.get_processing_query().all()
for file in files:
# emit the file_started event for *every* file that is currently being processed
socketio.emit("file_started", {"data": formatted_file_data(file)})
def leaveGame():
user = User.query.filter_by(id=session['user-info']['id']).first()
if user.game is None:
flash('You aren\'t in a game!', 'warning')
return redirect(url_for('.index'))
user.game = None
socketio.emit('anything', broadcast=True)
db.session.commit()
return redirect(url_for('.index'))
def stop_wtc(ard_nr):
'''
The main function for rendering the principal site.
'''
tc = WebTempControl.query.get(ard_nr);
tc.stop()
flash('Stopped the thermocontrol')
socketio.emit('close_conn',{'data': tc.conn_str()})
return redirect(url_for('main.index'))
def background_thread():
"""Example of how to send server generated events to clients."""
count = 0
while True:
time.sleep(120)
count += 1
socketio.emit('my response',
{'data': 'Server generated event', 'count': count, 'nickname': 'Server'},
namespace='/chat')
def leave_conference(conf_number, callerid):
if not asterisk_is_authenticated():
return 'NOTAUTH'
message = gettext('Number %(num)s has left the conference.', num=callerid)
conference = Conference.query.filter_by(number=conf_number).first_or_404()
conference.log(message)
socketio.emit('update_participants', {
'room': 'conference-%s' % conference.id
})
return 'OK'
def cancel_process(file_id):
"""
cancel a specific Process
:param file_id: the id of the file corresponding to the Process
"""
# stop thread
ProcessRepository.processes[file_id].stop()
# update status
file = File.query.filter_by(id=file_id).first()
file.status = StatusMap.failed.value
file.clear()
db.session.commit()
# emit file_done event
socketio.emit("file_done", {"data": formatted_file_data(file)})
# remove from processes dict
ProcessRepository.processes.pop(file_id)
def send_message(data):
user_ = User.query.filter_by(username=data['username']).first()
thread_ = thread.query.filter_by(subject=data['room']).first()
p = post(message=data['message'], user_id=user_.id, thread_id=thread_.id)
db.session.add(p)
db.session.commit()
p = post.query.filter_by(message=data['message'],
user_id=user_.id,
thread_id=thread_.id).first()
socketio.emit('received_message', {
'room': data['room'],
'user_id': p.user_id,
'username': user_.username,
'msg': p.message,
'post_id': p.id,
'thread_id': thread_.id
},
room=data['room'],
dif_user=p.user_id)
def switchClick_ack(data=None):
# if the callback is called with no data then just pass
if data is None:
return
parsed = json.loads(data)
oActuator = Actuator.query.filter_by(id=parsed['id']).first()
if oActuator is not None:
# Update database
oActuator.state_current = parsed['state']
db.session.commit()
# Update client-user's button state
aux = {
'id' : parsed['id'],
'state' : parsed['state'],
'class' : 'switch-onoff'
}
socketio.emit('updateState', data=aux, namespace='/client-user')
def picture(self):
"""Sends the last picture saved by the streaming
through a socket.
"""
pictures = sorted([f for f in os.listdir(self.stream_path)])
if len(pictures):
p = pictures[-1]
picture_path = os.path.join(self.stream_path, p)
while os.stat(picture_path).st_size == 0:
pass
return picture_path
else:
socketio.emit('msg2user', {'type': 'warning',
'msg': 'There is no picture to send'}, namespace='/car')
if self.verbose:
print('There is no picture to send')
return None
def RequestStation(data):
print("i am in")
try:
if (data['action'] == "drop"):
action = "D"
elif (data['action'] == "pick"):
action = "P"
msgToSend = "ST," + str(data['station_id']) + ",R," + str(
data['job_id']) + "," + str(
data['position']) + "|" + action + "|" + str(
data['bin_id']) + ";"
reply = checkRequest(data['station_id'], msgToSend)
if type(reply) is list:
if (reply[2] == 'A'):
requestReply = jsonFormat(
{
"station_id": data['station_id'],
"job_id": data['job_id'],
"status": "true",
"message": "Approved"
}, "")
else:
requestReply = jsonFormat(
{
"station_id": data['station_id'],
"job_id": data['job_id'],
"status": "false",
"message": "Denied"
}, "")
else:
requestReply = jsonFormat(
{
"station_id": data['station_id'],
"job_id": data['job_id'],
"status": "false",
"message": "Denied"
}, reply)
socketio.emit("request", requestReply, namespace='/station')
# emit("request", requestReply)
except Exception as e:
print(redBright(e))
def post(self, room_id):
song_file = request.files["song"]
if song_file.filename == "":
return {"status": "error", 'message': "Please select a file"}, 400
elif not (song_file and allowed_file(song_file.filename)):
return {
"status": "error",
'message': "Files must be in mp3 format."
}, 400
elif Room.query.filter_by(id=room_id).first() is None:
return {"status": "error", "message": "Room does not exist."}, 400
else:
link = None
try:
song_name = secure_filename(song_file.filename)
link = upload_file_to_s3(song_file, config.S3_BUCKET)
new_song = Song(name=song_name, link=link, room_id=room_id)
db.session.add(new_song)
except Exception as e:
if link is not None:
s3.delete_object(Bucket=config.S3_BUCKET,
Key=link[len(config.S3_LOCATION):])
db.session.rollback()
print(repr(e))
return {
"status":
"error",
'message':
"Something wrong happen while uploading new song. Please try again."
}, 400
db.session.commit()
result = song_schema.dump(new_song)
socketio.emit('playlist', {
'data': {
'room_id': room_id,
'action': 'song_added',
'data': result,
'message': 'Song ' + song_name + ' has been added.'
}
},
room=room_id)
return {"status": "success", "data": result}, 200
def end_turn(cls, game):
app.logger.debug(
'Ending turn for the game {game_id}'.format(game_id=game.game_id))
# End current turn
game.end_current_turn()
# Rank answers
ranked_players = game.get_current_turn_ranks()
player_count = len(ranked_players)
# Send the end of turn signal and the correct and best answer to every players in the game
city = game.get_current_city()
turn_results = {
'correct_answer': {
'name': city['name'],
'lat': city['latitude'],
'lng': city['longitude']
}
}
if player_count > 0:
turn_results['best_answer'] = {
'distance':
ranked_players[0].get_result(game.turn_number).distance,
'lat': ranked_players[0].get_answer(game.turn_number).latitude,
'lng': ranked_players[0].get_answer(game.turn_number).longitude
}
socketio.emit('end_of_turn', turn_results, room=game.game_id)
# Then send individual player results
for rank, player in enumerate(ranked_players):
socketio.emit('player_results', {
'rank': rank + 1,
'total': player_count,
'distance': player.get_result(game.turn_number).distance,
'score': player.get_result(game.turn_number).score,
'lat': player.get_answer(game.turn_number).latitude,
'lng': player.get_answer(game.turn_number).longitude
},
room=player.sid)
def create_chat_message(raw_message):
chat = Chat.query.get(raw_message['chatId'])
user = User.query.get(raw_message['userId'])
if (user and chat):
message = Message(chat_id=chat.id,
user_id=user.id,
text=raw_message['text'])
db.session.add(message)
db.session.commit()
socketio.emit(
'new-message',
json.dumps({
**prepare_message_to_send(message), 'isUnread': True
}))
socketio.emit('lastMessageUpdate', {
'chatId': chat.id,
'body': str(message)
})
def handle_join_room(data):
user = User.objects(username=data['username']).first()
# update point of user
point = user.point - 50
user.update(set__point=point)
# save sid of player
gameroom = get_gameroom(data['room'])
member0 = gameroom.members[0]
member1 = gameroom.members[1]
if member0.name == data['username']:
member0.sid = request.sid
else:
member1.sid = request.sid
gameroom.save()
join_room(data['room'])
data['info'] = 'connected'
socketio.emit('join-room-info', data, data['room'])
def get_model_detail_period(mid, sid, uids):
while sid in all_background_thread:
model_info = redis_func.get_model_status(mid)
device_info = []
for uid in uids:
res = redis_func.get_device_status(uid)
res["times"] = redis_func.get_device_model_contribute_time(
uid, mid)
res["status"] = redis_func.get_device_model_status(uid, mid)
device_info.append(res)
ret = {"model_info": model_info, "device_info": device_info}
socketio.emit('push_task_info',
ret,
namespace='/dashboard',
json=True,
room=sid)
socketio.sleep(5)
def languageChange(data):
LoadDB(data['language'])
global db
a = db.get_toml_data('Buildin')
stg = ''
for item in a:
stg += "<li><a class='dropdown-item' href='#' onClick='dropClicked(this)' data-value='" + item + "'>" + item + "</a></li>"
stg += "<li><div class='dropdown-divider'></div></li>"
a = db.get_toml_data('Custom')
for item in a:
stg += "<li><a class='dropdown-item' href='#' onClick='dropClicked(this)' data-value='" + item + "'>" + item + "</a></li>"
socketio.emit('lang_changed', stg, namespace='/generator')
def serious_chat(user1, user2, topic):
serious_queue.pop(0)
serious_queue.pop(0)
id1 = username[user1]
id2 = username[user2]
chats[id1] = id2
chats[id2] = id1
opinions = get_opinions()
socketio.emit('okay', {
'name': user1,
'topic': topic,
'opinion': opinions[0]
},
room=id1)
socketio.emit('okay', {
'name': user2,
'topic': topic,
'opinion': opinions[1]
},
room=id2)
def handle_channel(chn):
global profane
name = chn['name']
content = chn['message']
name_cleaned = profanity.censor(name)
content_cleaned = profanity.censor(content)
now = datetime.now().strftime('%A %I:%M:%S %p').lstrip("0").replace(
" 0", " ")
message_object = Channel(name=name_cleaned,
content=content_cleaned,
date_posted=now)
database.session.add(message_object)
database.session.commit()
json_chan = {'name': name_cleaned, 'content': content_cleaned, 'date': now}
socketio.emit('channel', json_chan)
def pco_set(data):
g = freeplay_games[data['gameid']]
player = g.get_player_from_session(current_user)
print('Client {}, event {}: {}'.format(get_stable_user(), 'PCO SET', data))
if not g.confirm_or_destroy_id(data['obj_id']):
return False
obj = g.all_movables[data['obj_id']]
obj.offset_per_dependent = [int(data['pco_x']), int(data['pco_y'])]
return_data = {
'movables_info': [{
'id': obj.id,
'offset_per_dependent': obj.offset_per_dependent
}]
}
socketio.emit('UPDATE',
return_data,
broadcast=True,
room=data['gameid'],
namespace='/freeplay')
g.time_of_last_update = time()
def right_to_eraser(data):
comment = ProjectComment.query.get(data['comment_id'])
print(sid_rooms.get(str(comment.author.id)), comment.author.id, sid_rooms)
# for sid in [request.sid, *list(map(lambda x: sid_rooms.get(x.id), comment.project.authors))]:
#
# if sid is None:
# continue
#
# print (sid)
# socketio.emit("right_to_eraser", {
# "project_id": data['project_id'],
# "comment_id": data['comment_id'],
# }, room=sid)
socketio.emit("right_to_eraser", {
"project_id": data['project_id'],
"comment_id": data['comment_id'],
},
room=request.sid)
def update_legend(self):
app.logger.debug('Updating legend')
legend_changes = []
ranks = self.game.get_current_turn_ranks()
for p in ranks:
p_name, p_color = self.game.colors_mapped[p.sid]
legend_changes.append(
(p_name, p_color,
p.get_result(self.game.turn_number).distance))
# for player_sid, player_name_and_color in self.game.colors_mapped.items():
# legend_item = [player_name_and_color[1], player_name_and_color[0]]
# if len(current_turn_players_results) > 0:
# legend_item.append(current_turn_players_results[player_sid])
# else:
# legend_item.append(0)
# legend_changes.append(legend_item)
socketio.emit('legend_changes', legend_changes)
def like(postID):
print(postID)
# chatroom = Chatroom.query.get_or_404(room_id)
post = Post.query.get_or_404(postID)
user = db.session.query(User).get(current_user.id)
if (not user.has_liked(post)):
user.like(post)
db.session.commit()
likedUsers = len(post.LikedUsers.all())
socketio.emit("likedUsers", {"likedUsers": likedUsers})
# user.ChatroomId = chatroom.id
# chatroom.Members.append(user)
# db.session.commit()
# flask_socketio.join_room(room_id)
# socketio.emit("join_b", {"ProfilePicture": current_user.ProfilePicture,
# "FirstName": current_user.FirstName,
# "Members" : getMembersAsList(chatroom.Members)
# }
# , room=room_id)
print(user.has_liked(post))
def creer_publication():
jeton = request.json["jeton"]
corps = request.json["corps"]
print(jeton)
print(corps)
print("publier un nouveau message: " + corps)
u = Utilisateur.query.filter_by(jeton=jeton).first_or_404()
publication = Publication(corps=corps, auteur=u)
db.session.add(publication)
db.session.commit()
id = publication.utilisateur_id
socketio.emit('nouvelle_publication', {
'id': id,
'corps': publication.corps
},
namespace='/chat')
return jsonify(publication.to_dict())
def ledClick_ack(data=None):
# if the callback is called with no data then just pass
if data is None:
return
parsed = json.loads(data)
oControllerLed = ControllerLed.query.filter_by(id=parsed['id']).first()
if oControllerLed is not None:
# Update database
oControllerLed.state_current = parsed['state']
db.session.commit()
# Update client-user's button state
aux = {
'id' : parsed['id'],
'state' : parsed['state'],
'state_colorshift' : oControllerLed.state_colorshift,
'class' : 'controller-onoff'
}
socketio.emit('updateState', data=aux, namespace='/client-user')
def test_connect():
app.data.console_queue.put("connected")
app.data.console_queue.put(request.sid)
if app.uithread == None:
app.uithread = socketio.start_background_task(
app.UIProcessor.start, current_app._get_current_object()
)
app.uithread.start()
if not app.data.connectionStatus:
app.data.console_queue.put("Attempting to re-establish connection to controller")
app.data.serialPort.openConnection()
socketio.emit("my response", {"data": "Connected", "count": 0})
address = app.data.hostAddress
data = json.dumps({"hostAddress": address})
print(data)
socketio.emit("message", {"command": "hostAddress", "data": data, "dataFormat":"json"}, namespace="/MaslowCNC",)
if app.data.pyInstallUpdateAvailable:
app.data.ui_queue1.put("Action", "pyinstallUpdate", "on")
def logout(self, name=-1):
resp = {
'status': 1,
'msg': ''
}
if request.method == 'POST':
if name and name != -1:
line_id = name
else:
line_id = get_line_id_by_current_user(self.datamodel.session)
socketio.emit('message', {
'action': 'logout',
'p': ''
},
namespace='/canary',
room=name)
resp = {
'status': 0,
'msg': 'logout success'
}
_datamodel = SQLAInterface(ProjectFiles, self.datamodel.session)
filters = _datamodel.get_filters()
filters.add_filter('name', FilterEqual, name)
count, item = _datamodel.query(filters=filters)
for i in item:
#g['is_logout'][name] = -2
i.status = -2
_datamodel.add(i)
global g
g['status'][i.me_id][name]['status'] = -1
#return redirect(self.route_base)
widgets = self._list()
return self.render_template('line_function.html',
title=self.list_title,
widgets=widgets,
is_logout=True,
resp=resp)
def play_round(self):
# increase round counter - round is 1 indexed, 1 == rd1
self.round += 1
# set who's turn it is to index 1 (dealer is index 0, so it's left of the dealer)
self.turn = self.round
self.trick_counter = 0
db.session.commit()
# let everyone know the round started
socketio.emit('server_message',
{'message': 'Round' + str(self.round) + "...FIGHT!!!"},
namespace=namespace)
socketio.emit('update_round_and_dealer', {
'round': self.round,
'dealer': self.get_dealer_name(self.round)
},
namespace=namespace)
# shuffle up n deal
self.deal()
def flip(self, no_update=False):
if (len(self.images) == 2):
if not isinstance(self, Dice):
self.show_face_number = 0 if self.show_face_number == 1 else 1
if not no_update:
self.game.thread_lock.acquire()
data = {
"movables_info": [{
"id":
self.id,
"show_face_number":
self.show_face_number,
}]
}
with app.test_request_context('/'):
socketio.emit('UPDATE',
data,
broadcast=True,
room=self.game.gameid,
namespace='/freeplay')
self.game.thread_lock.release()
def create_new_categ():
if not current_user or not current_user.is_authenticated or current_user.role_id != 2:
return json.dumps({"success": False})
new_categ = request.get_json(True)
categ = Categ(name=new_categ['name'],
color=new_categ['color'],
text_color=new_categ['textColor'],
params=new_categ['params'])
try:
db.session.add(categ)
db.session.commit()
except sqlalchemy.exc.IntegrityError:
db.session.rollback()
return json.dumps({
"success": False,
"message": 'Category already exists'
})
socketio.emit('reload')
return json.dumps({"success": True})
def sendMessageViaSocketIO(senderID, receiverID, message):
sender = User.objects.get(id=senderID)
messageDocument = Message(sender_id=sender,
receiver_id=receiverID,
message=message,
create_time=datetime.datetime.utcnow())
messageDocument.save()
data = {
"sender_id": {
"$oid": senderID,
"name": sender.name
},
"message": message,
"messageID": str(messageDocument.id),
"isRead": messageDocument.isRead
}
if receiverID != senderID:
socketio.emit(senderID + 'To' + receiverID, data, broadcast=True)
socketio.emit('messageTo' + receiverID, data, broadcast=True)
def handle_worker_action(msg, methods=['GET', 'POST']):
print('received worker action: ' + str(msg))
try:
worker_to_remove = msg['remove_']
print("removing worker %s ..." % worker_to_remove)
resp = json.dumps(
{'response': job_manager.delete_worker(worker_to_remove)})
socketio.emit('deletion_respone', resp)
except KeyError:
pass
try:
worker_to_add = int(msg['add_'])
print("adding %d workers ..." % worker_to_add)
spawn_success = [
job_manager.spawn_worker() for i in range(worker_to_add)
]
resp = json.dumps(
{'response': (sum(spawn_success) == len(spawn_success))})
socketio.emit('creation_respone', resp)
except KeyError:
pass
def getSlotDropdownList(data):
global db
#save the new slot info that came in
if data:
savenewslot(data)
a = db.get_toml_data('Buildin')
stg = ''
for item in a:
stg += "<li><a class='dropdown-item' href='#' onClick='dropClicked(this)' data-value='" + item + "'>" + item + "</a></li>"
stg += "<li><div class='dropdown-divider'></div></li>"
a = db.get_toml_data('Custom')
for item in a:
stg += "<li><a class='dropdown-item' href='#' onClick='dropClicked(this)' data-value='" + item + "'>" + item + "</a></li>"
socketio.emit('slotsDropDownList', {"html":stg}, namespace='/generator')
def index():
formulaire = FormulairePublication()
if formulaire.validate_on_submit():
publication = Publication(corps = formulaire.publication.data, auteur= current_user)
db.session.add(publication)
db.session.commit()
id = publication.id
socketio.emit('nouvelle_publication', {'id':id}, namespace='/chat')
flash('Votre publication est en ligne')
return redirect(url_for('index'))
utilisateur =current_user
page = request.args.get('page',1,type=int)
publication = current_user.Liste_publications_dont_je_suis_partisans().paginate(page,app.config['PUBLICATIONS_PAR_PAGE'],False)
#utilisateur = Utilisateur.query.all()
suivant = url_for('index',page= publication.next_num) \
if publication.has_next else None
precedent = url_for('index',page = publication.prev_num) \
if publication.has_prev else None
return render_template('index.html', titre='Accueil',suivant=suivant,precedent=precedent, utilisateur=utilisateur,publication=publication.items,formulaire=formulaire)
def background_thread(registrationToken, windowToken):
while mongoClient["tmpPatientToken"].count_documents({
'id': registrationToken,
'synced': False
}) == 1:
socketio.sleep(1)
#If a token has been marked as synced, redirect to index. If not, the user has pressed cancel
if mongoClient["tmpPatientToken"].count_documents({
'id': registrationToken,
'synced': True
}) == 1:
cursorRegistrationToken = mongoClient["tmpPatientToken"].find_one(
{'id': registrationToken})
insertPatient(windowToken, cursorRegistrationToken["name"], cursorRegistrationToken["surname1"], \
cursorRegistrationToken["surname2"], cursorRegistrationToken["age"], cursorRegistrationToken["gender"], \
cursorRegistrationToken["groups"], True)
mongoClient["tmpPatientToken"].delete_one({'id': registrationToken})
socketio.emit('redirect', namespace='/registerPatient')
def parse(self, response):
print("parsing")
page = Page()
page['url'] = response.url
page['content'] = response.xpath('//div[@id="mw-content-text"]')
page['content'] = page['content'].xpath(
'//div[@class="mw-parser-output"]//p//text()').extract()
#filter content
text_to_send = filter_text_from_content(page, query)
#print(text_to_send)
try:
print("socket")
socketio.emit("content", {
'data': text_to_send,
"_id": content_id
},
broadcast=True)
print("socket emit")
except Exception as e:
traceback.print_exc()
print("Exception", e)
