def get(self):
context = {"messages": []}
for error in self.session.get_flashes("error_messages"):
context["messages"].append(Message("danger", error[0]))
for error in self.session.get_flashes("success_messages"):
context["messages"].append(Message("success", error[0]))
self.response.write(get_template('index.html').render(context))
def login():
msg = request.args.get('msg', False)
if msg:
msg = Message(msg, 'success')
# redirect athenticated users
if current_user.is_authenticated:
return redirect(url_for('listOpenEvents'))
# serve login page for GET request
if request.method == 'GET':
return render_template('login.html', msg=msg)
# handle login for POST Request
# ignore invalid request
if not ('email' in request.form and 'password' in request.form):
# bad request
abort(400)
user, msg_str = ems.login(request.form['email'], request.form['password'])
if user:
login_user(user)
next = request.args.get('next')
if not is_safe_url(next):
return abort(400)
return redirect(next or url_for('listOpenEvents'))
else:
msg = Message(msg_str, 'danger')
return render_template('login.html', form=request.form, msg=msg)
def do_phrase(self):
m = Message(group=self.group_id)
if self.phrase == Game.Phrase.Planning:
self.loot_players = {}
self.loot = MDGlobal.loot_list[self.loot_index]
self.loot_index += 1
if self.loot.role != 0:
m.appendPlain(
f"谋划阶段：第{self.loot_index}轮\n当前银行战利品为{self.loot.loot}00万美金，保证金{self.loot.ante}00万美金，加成角色为{MDGlobal.card_name[self.loot.role]}\n")
else:
m.appendPlain(
f"谋划阶段：第{self.loot_index}轮\n当前银行战利品为{self.loot.loot}00万美金，保证金{self.loot.ante}00万美金\n")
for player in self.players:
player.role = Player.Role.TBD
player.exit = False
self.ante[player.qq_id] = player.minus_balance(self.loot.ante)
m.appendPlain("玩家")
m.appendAt(player.qq_id)
m.appendPlain(f"已缴纳保证金{self.ante[player.qq_id]}00万美金\n")
m.appendPlain("请玩家私聊 bot 输入 .md [角色名] 决定本回合要扮演的角色")
m.send()
elif self.phrase == Game.Phrase.Negotiation:
random.shuffle(self.players)
msg = "谈判阶段：\n目前已知晓的玩家身份有："
for i in range(1, len(self.players)):
msg += f'{MDGlobal.card_name[self.players[i].role]}、'
SendGroupPlain(group=self.group_id, msg=msg.strip())
elif self.phrase == Game.Phrase.TheHeist:
self.roles = [[], [], [], [], [], []]
for player in self.players:
if not player.exit:
self.roles[player.role].append(player)
snitches = self.roles[1]
if len(snitches) == 0:
SendGroupPlain(group=self.group_id, msg="无告密者，继续下一阶段")
self.phrase3_continue(0)
elif len(snitches) == 1:
m = Message()
m.appendPlain("告密者为")
m.appendAt(snitches[0].qq_id)
m.appendPlain("，请告密者输入 .md rm [角色种类] 决定要移除的角色")
self.loot_players[Player.Role.Snitch] = snitches[0]
m.send()
else:
m = Message()
m.appendPlain("告密者为")
for player in snitches:
m.appendAt(player.qq_id)
m.appendPlain("、")
m.appendPlain('\n所有告密者将被淘汰，并无法取回保证金')
m.send()
self.phrase3_continue(0)
def postEvent(eventType):
# see if given type is valid
classname = eventType.capitalize()
if not classname in Event.ALL_CATEGORY:
abort(400)
# serve corresponding post page for given type of event
if request.method == 'GET':
return render_template('post_{}.html'.format(eventType.lower()),
name=current_user.name)
if request.method == 'POST':
try:
# instantiate a new obj of class of given classname
eventData = Parser.ALL_DATA[classname].parseViewToModel(
request.form.to_dict())
# post event and retrieve the returned eid for the new event
eid = current_user.postEvent(ems, classname, eventData)
except (PostEventException, EventException) as err:
msg = Message(str(err), 'danger')
return render_template('post_{}.html'.format(eventType.lower()),
msg=msg,
name=current_user.name,
form=json.dumps(request.form))
return redirect(url_for('eventDetails', eid=eid))
async def callback_processor(self, request):
try:
data = await request.json()
if "type" not in data or "object" not in data:
raise ValueError("Damaged data received.")
except (UnicodeDecodeError, ValueError):
return web.Response(text="ok")
data_type = data["type"]
if data_type == "confirmation":
return web.Response(text=self.settings.CONF_CODE)
obj = data["object"]
if "user_id" in obj:
obj['user_id'] = int(obj['user_id'])
if data_type == 'message_new':
await self.process_message(
Message(self.api, MessageEventData.from_message_body(obj)))
else:
await self.process_event(CallbackEvent(self.api, data_type, obj))
return web.Response(text="ok")
def register(self):
'''init connection and login a exist user'''
if not isinstance(self.conn, socket.socket):
return False, 'Not Connected to server'.title()
conn = self.conn
msg = Message(kind=kind_register, sender=self.username, receiver='')
try:
conn.sendall(msg.inBytes)
except socket.error:
print(
'{}, RegisterError, can not send RegisterReq to server'.format(
localtime()))
return False, 'RegisterError, can not send RegisterReq to server'
data = conn.recv(1024)
try:
msg = Message.ParseBytes(data)
except:
print('{}, RegisterError, failed to parse server response'.format(
localtime()))
return False, 'RegisterError, failed to parse server response'
print(msg)
if msg.kind == kind_register and msg.token and isinstance(
msg.token, str) and msg.info == 'ok':
print('{}, RegisterAndLoginSuccess, token is {}'.format(
localtime(), msg.token))
self.token = msg.token
self.online = True
self.conn = conn, 'RegisterAndLoginSuccess'
return True
self.conn = None
self.token = None
conn.close()
return False, 'Register Failed'
def __send_data(self, conn, info, kind, token='', sender=None):
'''服务器发送信息给用户'''
message = Message(kind=kind, sender=server_name if sender is None else sender, receiver='', info=info, token=token)
try:
conn.sendall(message.inBytes)
return True
except:
return False
def show_balance(self):
m = Message(group=self.group_id)
for player in self.players:
m.appendAt(player.qq_id)
m.appendPlain(
f"：{player.balance}00万美金，威胁卡数量：{player.intimidation}\n")
m.strip()
m.send()
def __send_data_close(self, conn, info):
'''服务器发送警告消息后关闭连接'''
message = Message(kind="server_will_close", sender=server_name, receiver='', info=info)
try:
conn.sendall(message.inBytes)
except:
pass
finally:
conn.close()
def send_camera_error_messages(server, port1, port2):
m1 = Message()
m2 = Message()
m1.set_date_time()
m1.set_camera_status(-1)
m1.set_checksum()
m2.set_date_time()
m2.set_camera_status(-1)
m2.set_checksum()
logger.info("Message 1 is %s", m1.convert_to_string())
logger.info("Message 2 is %s", m2.convert_to_string())
print("Sending m1 to port:" + port1)
server.sendto(m1.convert_to_string().encode(), ('<broadcast>', int(port1)))
print("Sending m2 to port:" + port2)
server.sendto(m2.convert_to_string().encode(), ('<broadcast>', int(port2)))
def get_all_users(self):
if not self.online:
return False
msg = Message(
kind=kind_get_all_users,
sender=self.username,
receiver='',
)
self.q.put_nowait((2, msg))
return True
def emotion(self, receiver='', info=''):
'''student send emotion, teacher reply to emotion'''
msg = Message(kind=kind_emotion,
sender=self.username,
receiver=receiver,
info=info,
token=self.token)
print('emotion', msg)
self.q.put_nowait((1, msg))
return True
def p2p_chat(self, receiver, info):
'''chat one to one'''
if not self.online:
return False
msg = Message(kind=kind_p2p_chat,
sender=self.username,
receiver=receiver,
info=info,
token=self.token)
self.q.put_nowait((1, msg))
return True
def broadcast(self, info):
'''广播消息'''
message = Message(kind='BroadCasting', sender=server_name, receiver='', info=info)
for conn in conn_user_map:
try:
receiver = conn_user_map[conn]
conn.sendall(message.inBytes)
except:
if 'receiver' in locals():
receiver = locals()['receiver']
self.logout(user_name=receiver.username)
def p2p_chat(self, sender, receiver, info, kind='p2p_chat'):
'''点对点聊天'''
if self.check_user(receiver) != usr_online:
return False
receiver = users[receiver]
conn = receiver.conn
message = Message(kind=kind, sender=sender, receiver='', info=info)
try:
conn.sendall(message.inBytes)
return True
except:
self.logout(receiver)
return False
def send(self):
myself = Subscriber()
myself.port = DEFAULT_PORT
myself.ip = 'localhost'
myself.id = 'app2'
message = Message()
message.type = 'subscription'
message.senderID = 'app2'
message.receiverID = 'broker'
message.body = myself
self.netWriter.write('broker', message)
def remove_player(self, user_id):
m = Message(group=self.group_id)
for i in range(len(self.players)):
if self.players[i].qq_id == user_id:
m.appendAt(self.players[i].qq_id)
m.appendPlain("退出成功")
m.send()
self.players[i].destruct()
del self.players[i]
return
m.appendPlain("未找到")
m.appendAt(user_id)
m.send()
async def process_longpoll_event(self, new_event):
if not new_event:
return
event_id = new_event[0]
if event_id != 4:
evnt = LongpollEvent(self.api, event_id, new_event)
return await self.process_event(evnt)
data = MessageEventData()
data.msg_id = new_event[1]
data.attaches = new_event[6]
data.time = int(new_event[4])
if 'from' in data.attaches and len(new_event) > 3:
data.user_id = int(data.attaches.pop('from'))
data.chat_id = int(new_event[3]) - 2000000000
data.is_multichat = True
else:
data.user_id = int(new_event[3])
data.is_multichat = False
# https://vk.com/dev/using_longpoll_2
flags = parse_msg_flags(new_event[2])
if flags['outbox']:
if not self.settings.READ_OUT:
return
data.is_out = True
data.full_text = new_event[5].replace('<br>', '\n')
if "fwd" in data.attaches:
data.forwarded = MessageEventData.\
parse_brief_forwarded_messages_from_lp(data.attaches.pop("fwd"))
else:
data.forwarded = []
msg = Message(self.api, data)
if await self.check_event(data.user_id, data.chat_id, data.attaches):
msg.is_event = True
await self.process_message(msg)
def signup():
# serve page on GET request
if request.method == 'GET':
return render_template('signup.html')
# handle registration form
try:
userData = UserData.parseViewToModel(request.form)
newGuest = Guest(userData)
ems.addUser(newGuest)
except Exception as err:
msg = Message(str(err), 'danger')
return render_template('signup.html',
msg=msg,
form=json.dumps(request.form))
return redirect(url_for('login', msg='Successfully signed up'))
def heart_beat(self):
'''send heart beat package every 5 s'''
while self.flag:
if self.conn is None:
print('{}, NoConnection, heartbeat skip.'.format(localtime()))
continue
if self.token is None:
print('{}, NoToken, heartbeat skip.'.format(localtime()))
msg = Message(kind=kind_heartbeat,
sender=self.username,
receiver='',
token=self.token)
try:
self.q.put_nowait((8, msg))
except socket.error:
self.online = False
time.sleep(5)
def try_end_game(self):
m = Message(group=self.group_id)
max_player = None
max_value = 0
for player in self.players:
if self.loot_index == 8 or player.balance >= 20:
if player.balance > max_value:
max_player = player
max_value = max_value
if max_player is not None:
self.reset()
self.status = Game.Status.Pending
m.appendPlain("游戏结束！玩家")
m.appendAt(max_player.qq_id)
m.appendPlain("胜利！\n如果需要再次开始游戏，请输入.md start")
m.send()
return True
return False
def re_login_with_token(self):
if self.online is False and self.token:
if self.conn is not None:
self.init_connect()
conn = self.conn
msg = Message(kind=kind_relogin,
sender=self.username,
receiver='',
token=self.token)
try:
conn.sendall(msg.inBytes)
except socket.error:
print('{}, ReLoginError, can not send ReLoginReq to server'.
format(localtime()))
return False
self.conn = conn
return True
return False
def login(self):
if not isinstance(self.conn, socket.socket):
return False, 'Not Connected to server'.title()
conn = self.conn
# send to server username
msg = Message(kind=kind_login, sender=self.username, receiver='')
try:
conn.sendall(msg.inBytes)
except socket.error:
print('{}, LoginError, can not send LoginReq to server'.format(
localtime()))
return False, 'LoginError, can not send LoginReq to server'
# receive server response to login req
data = conn.recv(1024)
# print('receive server response to login req', data)
try:
msg = Message.ParseBytes(data)
except:
print('{}, LoginError, failed to parse server response'.format(
localtime()))
print(str(data, encoding='utf-8'))
return False, 'LoginError, failed to parse server response'
print(msg)
if msg.kind in [kind_login,
kind_register] and msg.token and isinstance(
msg.token, str) and msg.info == 'ok':
print('{}, LoginSuccess, token is {}'.format(
localtime(), msg.token))
self.token = msg.token
self.online = True
self.conn = conn
return True, 'LoginSuccess'
self.conn = None
self.token = None
conn.close()
return False, msg.info
def handle(self):
c = self.request
print(localtime(), c)
try:
message = Message(kind=server_ask_username, sender=server_name, receiver='', info=welcome_msg)
c.sendall(message.inBytes)
except:
c.close()
return
try:
data = c.recv(1024)
except:
c.close()
return
try:
message = Message.ParseBytes(data)
except:
self.__send_data_close(c, invalid_msg)
return
# print(message, users)
user_name = message.sender
# print('check', message.kind)
# 处理用户登陆
if message.kind == 'Login':
self.login(c, user_name)
# 处理用户注册
elif message.kind == kind_register:
self.register(c, user_name)
# 处理已登陆用户重联 --- 用户不稳定的网络
elif message.kind == kind_relogin:
result = self.re_login_with_token(c, message.sender, message.token)
if result is not True:
self.__send_data_close(c, invalid_token)
return
else:
if not self.__send_data(conn=c, info='ok', kind=kind_relogin):
c.close()
return
else:
self.__send_data_close(c, invalid_msg)
return
while True:
if running is not True:
break
try:
data = c.recv(1024)
except:
self.logout(user_name)
break
try:
message = Message.ParseBytes(data)
except:
continue
sender = message.sender
info = message.info
receiver = message.receiver
kind = message.kind
status = message.status
token = message.token
if token is None:
self.__send_data_close(c, invalid_token)
break
if token not in token_user_map:
self.__send_data_close(c, invalid_token)
break
# 心跳
if kind == kind_heartbeat:
if token in token_user_map \
and token_user_map[token].token == token \
and sender == token_user_map[token].username:
self.__send_data(c, 'ok', 'HeartBeat')
else:
self.__send_data_close(c, invalid_token)
break
# 用户登出
if kind == kind_exit:
self.logout(user_name)
break
# 获取用户列表和用户状态
if kind == kind_get_all_users:
self.__send_data(conn=c, info=json.dumps(self.users_status_batch), kind=kind)
continue
# 获取某个用户的状态
if kind == kind_get_user_status:
self.__send_data(c, self.check_user(info), kind)
continue
# p2p chat
if kind == kind_p2p_chat:
receiver = users[receiver]
self.__send_data(receiver.conn, info=info, kind=kind) # todo: the partner offline
###############################################################
# 用户情绪
###############################################################
if kind == kind_emotion:
# emotions.append(message)
sender_ = users[sender]
if sender_.occupation == 'student':
teacher = users['teacher']
self.__send_data(
teacher.conn,
info={
'talk': message.info,
'mood': ai_api(message)
# 利用ai把学生的发言分析成-1，0， +1中的一个，并发送给教师端
},
kind=kind_emotion,
sender=sender
)
print(teacher, teacher.conn,)
elif sender_.occupation == 'teacher':
if not receiver:
continue
student = users[receiver]
self.__send_data(
student.conn,
info=message.info,
kind=kind_emotion,
sender=sender
)
def home():
return render_template("index.html", static_commands=static_commands.keys(), commands=[(key, commands[key].DESCRIPTION) for key in commands])
# Module interfaces
@app.route("/memes")
@cache.cached(timeout=CACHE_TIMEOUT)
def memes():
return render_template("memes.html",
memes=zip(commands["meme"].templates.keys(),
[len(commands["meme"].templates[template]) - 1 for template in commands["meme"].templates]))
@app.route("/analytics/<group_id>")
def analytics(group_id):
# TODO: clear up users/leaderboards naming
users = commands["analytics"].leaderboards.get(group_id)
return render_template("analytics.html", users=users)
# Local testing
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("command", nargs="?")
args = parser.parse_args()
if args.command:
print(process_message(Message(text=args.command)))
else:
while True:
print(process_message(Message(text=input("> "))))
def getMessage(buf, opcode, cmd, userid, password, qa, status=""): header = Header(opcode, cmd) message = Message(header, buf, userid, password, qa, status) return message
def envoyer(self, commande, *args):
msg = Message(commande, *args)
print("Serveur:", self.coords, "<<<", msg)
msg.envoyer(self.__socket)
async def bots_longpoll_processor(self):
pack = [{'act': 'a_check', 'key': '', 'ts': 0, 'wait': 25}, ""]
await self.init_bots_long_polling(pack)
session = aiohttp.ClientSession(loop=self.loop)
self.sessions.append(session)
while True:
try:
requ = session.get(pack[1], params=pack[0])
except aiohttp.ClientOSError:
await asyncio.sleep(0.5)
continue
self.requests.append(requ)
try:
events = json.loads(await (await requ).text())
except aiohttp.ClientOSError:
try:
self.sessions.remove(session)
except ValueError:
pass
await asyncio.sleep(0.5)
session = aiohttp.ClientSession(loop=self.loop)
self.sessions.append(session)
continue
except (asyncio.TimeoutError, aiohttp.ServerDisconnectedError):
self.logger.warning(
"Long polling server doesn't respond. Changing server.")
await asyncio.sleep(0.5)
await self.init_bots_long_polling(pack)
continue
except ValueError:
await asyncio.sleep(0.5)
continue
finally:
if requ in self.requests:
self.requests.remove(requ)
failed = events.get('failed')
if failed:
err_num = int(failed)
if err_num == 1: # 1 - update timestamp
if 'ts' not in events:
await self.init_bots_long_polling(pack)
else:
pack[0]['ts'] = events['ts']
elif err_num in (2, 3): # 2, 3 - new data for long polling
await self.init_bots_long_polling(pack, err_num)
continue
pack[0]['ts'] = events['ts']
for event in events['updates']:
if "type" not in event or "object" not in event:
continue
data_type = event["type"]
obj = event["object"]
if "user_id" in obj:
obj['user_id'] = int(obj['user_id'])
if data_type == 'message_new':
await self.process_message(
Message(self.api,
MessageEventData.from_message_body(obj)))
else:
await self.process_event(
CallbackEvent(self.api, data_type, obj))
def reply(message, group_id):
send(process_message(Message(message)), group_id)
name=player.name,
score=len(player.won)), group_id)
send("The next black card is \"{card}\" and {name} is now Czar.".format(card=game.current_black_card,
name=player.name), group_id)
else:
remaining_players = game.player_choose(user_id, data["card_index"])
send(f"{player.name} has played a card. {remaining_players} still need to play.", group_id)
# TODO: refresh EVERYONE, not just the selector!!
cah_ping(access_token)
if __name__ == "__main__":
while True:
print(process_message(Message({"attachments": []},
input("> "),
name="Tester",
group_id="49940116",
avatar_url="https://i.groupme.com/563x563.jpeg.d055af594625412fab6b5a66dbb27693")))
discord_client = discord.Client()
async def start():
await discord_client.start(os.environ.get("DISCORD_TOKEN"))
def run_loop(loop):
loop.run_forever()
