def userConnected():
session.pop("currentChat", None)
join_room(session.get("user").get("id"))
chatRooms = db.session.query(ChatRoom).filter(
(ChatRoom.senderID == session.get("user").get("id"))
| (ChatRoom.recipientID == session.get("user").get("id"))).all()
allChats = []
for chatRoom in chatRooms:
if chatRoom.senderID == session.get("user").get("id"):
userID = chatRoom.recipientID # other user
else:
userID = chatRoom.senderID
recipientUser = db.session.query(User).filter(
(User.id == userID)).first()
lastMessage = db.session.query(Message).filter(
(Message.chatID == chatRoom.id)).order_by(
Message.datetime.desc()).first()
message = {
"message": lastMessage.message,
"datetime": json.dumps(lastMessage.datetime,
default=stringifyDateTime)
}
if recipientUser and lastMessage:
allChats.append({
"chatID": chatRoom.id,
"userID": userID,
"firstName": recipientUser.firstName,
"lastMessage": message
})
socketio.emit("chatRooms", allChats, room=session.get("user").get("id"))
def update_game_round():
current_game_state = dict()
game_cells = list()
games_exist = GameOfLifeGame.query.scalar()
if not games_exist:
return
game = GameOfLifeGame.query.first()
cells = GameOfLifeCell.query.filter_by(game=game).all()
for cell in cells:
coordinates = (cell.x, cell.y)
is_alive = cell.is_alive
color = cell.color
current_game_state[coordinates] = {
"is_alive": is_alive,
"color": color
}
for cell in cells:
cell_state = _get_cell_state(cell, current_game_state)
alive_next_round, color = _is_alive_next_round(cell_state,
current_game_state)
if alive_next_round is not None:
cell.is_alive = alive_next_round
cell.color = color
db.session.commit()
alive = 1 if cell.is_alive else 0
game_cells.append((cell.x, cell.y, alive, cell.color))
socketio.emit("gameUpdate", game_cells)
def locationupdate(location):
"""Docstring LOL"""
info = {
'x': location['x'],
'y': location['y']
}
socketio.emit('location_info', info)
def on_status(self, data):
to_emit = transform_data(data)
with application.test_request_context('/'):
try:
socketio.emit('tweet', to_emit, broadcast=True)
except socket.timeout:
print("Socket timed out. Disconnecting...")
socketio.server.disconnect(self.sid)
return False
return True
def broadcast_game_state(game=None):
if game is None:
game = GameOfLifeGame.query.first()
game_cells = list()
cells = GameOfLifeCell.query.filter_by(game=game).all()
for cell in cells:
alive = 1 if cell.is_alive else 0
game_cells.append((cell.x, cell.y, alive, cell.color))
socketio.emit("gameUpdate", game_cells)
def update(self, doc):
"""Synchronise the model's attributes to the
corresponding mongodb document. Call player_died
on the current match model if the life field value
is 0.
"""
MongoModel.update(self, doc)
socketio.emit('response', {'player_id': str(self._id), 'life': self.life})
if self.life is 0:
match = self.get_current_match()
if match is not None:
match.player_died(self._id)
return self
def user_disconnect():
"""退出房间"""
keys_list = redis.keys("*_%s" % request.sid)
if len(keys_list) > 0:
room_dict = keys_list[-1]
uid = redis.get(room_dict).decode()
room = "_".join(room_dict.decode().split("_")[:2])
redis.delete(keys_list[-1].decode())
message = user_log(room, uid, "%s退出了房间")
socketio.emit("login_response",
message,
namespace="/mofang",
room=room)
leave_room(room)
else:
print("用户%s退出了房间" % request.sid)
def quotations_func(mes):
"""客户端连接"""
print('客户端连接')
print(mes)
sid = request.sid # io客户端的sid, socketio用此唯一标识客户端.
print('客户端sid')
print(sid)
with open('utils/my_rsa_public.pem', 'r') as file:
PUBLIC_KEY = file.read()
global user_sid
# 有用户连接先判断user_sid里是否已记录了该用户，
# 如果已经记录就覆盖原先的sid，如果没有就添加该用户
if len(user_sid) == 0: # 第一个用户先添加
user_sid.append({'user': mes['user'], 'sid': sid})
else:
flag = True
for i in range(len(user_sid)):
if user_sid[i]['user'] == mes['user']: # 该用户已存在于列表中
user_sid[i] = {'user': mes['user'], 'sid': sid}
flag = False
if flag: # 如果没找到该用户就添加
user_sid.append({'user': mes['user'], 'sid': sid})
print(user_sid)
can = False
host = request.host
host_list = ['127.0.0.1']
"""
根据页面的访问地址决定是否允许连接, 你可以自己实现自己对访问的控制逻辑.
最后决定是允许连接还是使用socketio.server.disconnect(sid)断开链接.
"""
if host in host_list:
can = True
elif host.startswith("192.168") or host.startswith("172") or host.startswith("local"):
can = True
else:
pass
if can:
print('允许连接')
socketio.emit(event="login",
data=json.dumps({"message": "connect success!", "sid": sid, "PUBLIC_KEY": PUBLIC_KEY}))
else:
print('拒绝连接')
socketio.emit(event="login", data=json.dumps({"message": "connect refuse!"}))
socketio.server.disconnect(sid)
def send(chat_id, text, message_type):
"""Отправляет сообщение в базу для сохранения
:param chat_id: Номер чата
:param text: Содержание сообщения
:param message_type: Тип сообщения
:return: Объект созданного сообщения
"""
message = Message(text, chat_id, message_type)
db.session.add(message)
db.session.commit()
User.register_message(message.id)
if app.config['SOCKET_MODE'] == 'True':
socketio.emit('message',
message.get_info(),
room=str(chat_id),
broadcast=True)
return message
def user_log(room, uid, content):
query = {"_id": room}
user = User.query.get(uid)
if user is None:
message = {
"errno": status.CODE_NO_USER,
"errmsg": errmsg.user_not_exists,
}
socketio.emit("login_response",
message,
namespace="/mofang",
room=room)
return
name = user.nickname if user.nickname else user.name
message = {
"uid":
user.id,
"sid":
request.sid,
"user":
name,
"avatar":
user.avatar if user.avatar else current_app.config["DEFAULT_AVATAR"],
'created_time':
int(datetime.now().timestamp()),
}
if "%s" in content:
message["log"] = content % name
else:
message["message"] = content
chat_list = mongo.db.user_chat_list.find_one(query)
if not chat_list:
mongo.db.user_chat_list.insert_one(query, {"stream_name": room})
key = "%s_%s" % (room, request.sid)
print(key)
redis.set(key, user.id)
mongo.db.user_chat_list.update_one(query,
{"$push": {
"message_list": message
}})
return message
def message(form):
form = SendMessageForm(formdata=MultiDict(form), meta={'csrf': False})
if not form.validate():
print(form.recipientID.errors + form.message.errors)
# socketio.emit("sendMessageError", {"recipientEmail": form.recipientEmail.errors})
else:
datetime = form.datetime.data
chatID = form.chatID.data
recipientID = form.recipientID.data
message = form.message.data
# socketio.emit("sendMessageError", {"recipientEmail": ""})
id = Message.query.count() + 1
newMessage = Message(id=id,
datetime=datetime,
chatID=chatID,
senderID=session["user"]["id"],
message=message)
db.session.add(newMessage)
db.session.commit()
socketio.emit("sentMessage", {
"chatID": chatID,
"recipientID": recipientID,
"senderID": session.get("user").get("id"),
"message": message,
"datetime": datetime
},
room=session.get("user").get("id"))
user = db.session.query(User).filter(
(User.id == session["user"]["id"])).first()
socketio.emit("receivedMessage", {
"chatID": chatID,
"recipientID": recipientID,
"senderID": session.get("user").get("id"),
"message": message,
"datetime": datetime,
"firstName": user.firstName
},
room=recipientID)
def changeChat(userID, chatID):
session["currentChat"] = userID
messages = db.session.query(Message).filter(
(Message.chatID == chatID)).all()
allMessages = []
for message in messages:
messageType = "receivedMessage"
if session["user"]["id"] == message.senderID:
messageType = "sentMessage"
allMessages.append({
"chatID":
chatID,
"messageType":
messageType,
"datetime":
json.dumps(message.datetime, default=stringifyDateTime),
"message":
message.message
})
socketio.emit("displayAllMessages",
allMessages,
room=session["user"]["id"])
def send(chat_id, code_text, parent, message):
"""Отправление кода на сервер
:param chat_id: Номер чата
:param code_text: Код
:param parent: Место в дереве коммитов
:param message: Комметарий к коду
:return: Сообщение о коммите и номере кода
"""
code_params = {
"content": code_text,
"message": message,
"chat_link": chat_id,
"parent_link": parent
}
code_to_send = Code(**code_params)
db.session.add(code_to_send)
db.session.commit()
message_text = Code.SYS_MESSAGE_ADD_TEMPLATE.format(
number=code_to_send.number, message=message)
Message.send(chat_id, message_text, Message.SYSTEM_TYPE)
if app.config['SOCKET_MODE'] == 'True':
socketio.emit('commit', room=str(chat_id), broadcast=True)
return code_to_send.id
def handshake(request):
"""Handshake pattern I've noticed is necessary in establishing connection"""
if request['key'] == 'hand':
socketio.emit('handshake_to_client', {'key': 'shake'})
def user_message(data):
"""用户发送文本信息"""
print(data)
room = data["stream_name"]
message = user_log(room, data["uid"], data["message"])
socketio.emit("login_response", message, namespace="/mofang", room=room)
def user_login(data):
# 进入房间
room = data["stream_name"]
join_room(room)
message = user_log(room, data["uid"], "%s进入了房间")
socketio.emit("login_response", message, namespace="/mofang", room=room)
def on_error(self, status):
if status == 401:
print('SocketIO disconnected')
socketio.server.disconnect(self.sid)
socketio.emit('error', status, broadcast=True)
def handshake(request):
"""Handshake pattern I've noticed is necessary in establishing connection"""
if request['key'] == 'hand':
socketio.emit('handshake_to_client', {'key': 'shake'})
def locationupdate(location):
"""Docstring LOL"""
info = {'x': location['x'], 'y': location['y']}
socketio.emit('location_info', info)
def manage_auction(form, username):
error = None
if 'token_id' not in form:
error = 'Token ID is required.'
try:
int(form['token_id'])
except ValueError:
error = "Enter an integer for token ID."
if 'price' not in form:
error = 'Price is required.'
try:
int(form['price'])
except ValueError:
error = "Enter an integer for price"
if error is None:
token_id = int(form['token_id'])
price = int(form['price'])
if form['type'] == 'new':
if price < int(
get_current_price_from_token_id(token_id) * 1.1) + 1:
return json.dumps({"status": 404, 'e': 'Price is not enough'})
if token_id in dict_bid and dict_bid[token_id][0] + timedelta(
minutes=3) > datetime.utcnow():
return json.dumps({
"status":
404,
'e':
'Someone process a bid, retry in few seconds'
})
dict_bid[token_id] = [datetime.utcnow(), username, price]
return json.dumps({
'status': 200,
'to': ADDRESS_ALGO_OURSELF,
'amount': price * 1000000,
'note': f"{username}_{token_id}"
})
if form['type'] == 'error_new':
dict_bid.pop(token_id, None)
return "Delete from queue"
if form['type'] == 'validate_new':
if 'address' not in form:
error = 'Address is required.'
if 'txID' not in form:
error = 'Transaction ID is required.'
if error is None:
address = form['address']
tx_id = form['txID']
price = int(price / 1000000)
if verify_bid_transaction(tx_id, price, username, token_id,
address):
if username == dict_bid[token_id][1] and price == dict_bid[
token_id][2]:
old_price = int(
get_current_price_from_token_id(token_id))
old_address = get_previous_bidder(token_id)
execute_bid(token_id, price, address)
dict_bid.pop(token_id, None)
socketio.emit(
"new", data=[str(int(price * 1.1) + 1), token_id])
if old_address is not None:
tx_id = transfer_algo_to_user(
old_address, old_price * 1000000)
if verify_buy_transaction(tx_id):
return "Bid was done."
else:
tx_id = transfer_algo_to_user(address, price * 1000000)
if verify_buy_transaction(tx_id):
return "Refund"
else:
return "Transaction does not exist"
return error
return redirect(url_for('main.feed'))
return error
def listen_func(data):
""""监听发送来的消息,并使用socketio向所有客户端发送消息"""
sender_sid = request.sid
global user_sid
for i in range(len(user_sid)):
if user_sid[i]['user'] == data['user']:
user_sid[i] = {'user': data['user'], 'sid': sender_sid}
print(data)
value = data['data']
value = value.replace('%u', '\\u') # 将%uxxxx 替换换 \uxxxx 这才可以进行utf-8解码
byts = urllib.parse.unquote_to_bytes(value) # 返回的 byte
data['data'] = byts.decode('unicode-escape') # decode UTF-8 解码只能解开 \uXXXX 的Unicode 标准形式
print(data['data'])
default_length = 128
private_key = RSA.import_key(
open("utils/my_private_rsa_key.bin").read(),
passphrase='123456'
)
encrypt_byte = base64.b64decode(data['data'].encode())
length = len(encrypt_byte)
cipher_rsa = PKCS1_v1_5.new(private_key)
if length < default_length:
decrypt_byte = cipher_rsa.decrypt(data['data'], None)
else:
offset = 0
res = []
while length - offset > 0:
if length - offset > default_length:
res.append(cipher_rsa.decrypt(encrypt_byte[offset: offset +
default_length], 'failure'))
else:
res.append(cipher_rsa.decrypt(encrypt_byte[offset:], 'failure'))
offset += default_length
decrypt_byte = b''.join(res)
data['data'] = decrypt_byte.decode()
print(data['data'])
value = data['data']
value = value.replace('%u', '\\u') # 将%uxxxx 替换换 \uxxxx 这才可以进行utf-8解码
byts = urllib.parse.unquote_to_bytes(value) # 返回的 byte
data['data'] = byts.decode('unicode-escape') # decode UTF-8 解码只能解开 \uXXXX 的Unicode 标准形式
print(data['data'])
mes = {"message": "unknown error"}
# data = request.args['data'] if request.args.get('data') else request.form.get('data')
# sid = request.args['sid'] if request.args.get('sid') else request.form.get('sid')
print(sender_sid)
print(user_sid)
'''
两种逻辑实现chat
1.向除了自己的所有人发送信息
2.找到要发送用户对应的sid向该用户（sid）发送信息
'''
'''
方法一
'''
# if data is not None:
# if sender_sid == user_sid[0]['sid']:
# print('a')
# print(user_sid[1]['sid'])
# socketio.emit(data=data, event="mes", room=user_sid[1]['sid']) # js客户端on绑定的就是这个event的事件
# mes['message'] = "success"
# else:
# print('b')
# print(user_sid[0]['sid'])
# socketio.emit(data=data, event="mes", room=user_sid[0]['sid']) # js客户端on绑定的就是这个event的事件
# mes['message'] = "success"
# else:
# pass
# sql = "select avatar from user where login_name='%s'" % (data['target'])
# avatar = '../static/user_pics/' + opm.op_select(sql)[0]['avatar']
'''
方法二
'''
data['target'] = data['target'].replace(' ', '').replace('\n', '')
if data is not None:
for i in range(len(user_sid)):
print('sender' + data['user'])
print('target' + data['target'])
if data['target'] == user_sid[i]['user']:
# data.update({'target_avatar': avatar})
socketio.emit(data=data, event="mes", room=user_sid[i]['sid']) # js客户端on绑定的就是这个event的事件
mes['message'] = "success"
else:
pass
return json.dumps(mes)
def receivedMessage(data):
if data["senderID"] == session.get("currentChat"):
socketio.emit("displayReceivedMessage", data, room=data["recipientID"])
else:
socketio.emit("displayNotification", data, room=data["recipientID"])
