def test_get_unread_messages_query(self):
message_1 = Message(text='hi arthur',
sender=self.bob,
recipient=self.arthur,
chat=self.chat_bob_arthur,
was_read=True)
message_2 = Message(text='hi bob',
sender=self.arthur,
recipient=self.bob,
chat=self.chat_bob_arthur)
message_3 = Message(text='what\'s up',
sender=self.arthur,
recipient=self.bob,
chat=self.chat_bob_arthur)
message_4 = Message(text='see you',
sender=self.arthur,
recipient=self.bob,
chat=self.chat_bob_arthur,
was_read=True)
database.session.add_all([message_1, message_2, message_3, message_4])
database.session.commit()
messages = self.bob.get_unread_messages_query(self.chat_bob_arthur)
self.assertIn(message_2, messages.all())
self.assertIn(message_3, messages.all())
self.assertEqual(len(messages.all()), 2)
def message_reply_api():
content = request.form['content']
author = request.form['author']
email = request.form['email']
message_id = request.form['message_id']
password = request.form['password']
code = int(request.form['code'])
pattern = '^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$'
email_ok = re.match(pattern,email,flags=0)
if content != '' and author != '' and email != '':
if email_ok != None:
admin_flag = False
user = User.query.first()
if user.verify_password(password):
admin_flag = True
author = user.nickname
if code == 0:
message = Message(content=content, author=author,
email=email, date=datetime.now(), admin_flag=admin_flag, replied_id=message_id)
else:
origin_author = request.form['origin_author']
content = '回复@' + origin_author + '# ' + content
message = Message(content=content, author=author,
email=email, date=datetime.now(), admin_flag=admin_flag, replied_id=message_id)
db.session.add(message)
db.session.commit()
result = {'status': 0}
else:
result = {'status': 1}
else:
result = {'status': 2}
return jsonify(result)
def reply(chat_id):
chat = Chat.query.filter_by(id=chat_id).first_or_404()
request_text = request.form['msg']
request_msg = Message(chat_id=chat_id,
text=request_text,
author=Message.AUTHOR_USER,
order=chat.messages_count + 1)
if app.config['NEURAL_LOGIC']:
from app import sess, model, enc_vocab, rev_dec_vocab
response_text = execute.decode_line(sess, model, enc_vocab,
rev_dec_vocab, request_text)
else:
response_text = request.form['msg']
response_msg = Message(chat_id=chat_id,
text=response_text,
author=Message.AUTHOR_BOT,
order=chat.messages_count + 2)
for word in basic_tokenizer(request_text.encode()):
db.session.add(UserWord(word=word))
for word in basic_tokenizer(response_text.encode()):
db.session.add(BotWord(word=word))
chat.messages_count = chat.messages_count + 2
db.session.add(request_msg)
db.session.add(response_msg)
db.session.commit()
return jsonify(response_msg.as_dict())
def test_chat_two_users_1(self):
message1 = Message(text='hi there1',
sender=self.arthur,
recipient=self.bob,
was_read=True,
chat=self.chat_bob_arthur)
message2 = Message(text='hi there2',
sender=self.arthur,
recipient=self.bob,
was_read=True,
chat=self.chat_bob_arthur)
message3 = Message(text='hi there3',
sender=self.arthur,
recipient=self.bob,
chat=self.chat_bob_arthur)
message4 = Message(text='hi there4',
sender=self.arthur,
recipient=self.bob,
chat=self.chat_bob_arthur)
database.session.add_all([message1, message2, message3, message4])
database.session.commit()
user_chats = (database.session.query(Chat).join(
UserChatTable, (UserChatTable.c.user_id == self.bob.id)
& (UserChatTable.c.chat_id == Chat.id)).subquery())
found_chat = (database.session.query(Chat).join(
UserChatTable, (UserChatTable.c.user_id == self.arthur.id)
& (UserChatTable.c.chat_id == Chat.id)).join(user_chats).first())
self.assertEqual(self.chat_bob_arthur, found_chat)
def test_get_number_of_all_messages(self, user_1, user_2,
channel_to_test) -> None:
app.config['WTF_CSRF_ENABLED'] = False
with app.app_context():
db.drop_all()
db.create_all()
db.session.add(user_1)
db.session.add(user_2)
db.session.add(channel_to_test)
with app.test_client() as c:
rv = login(c, user_1.email, 'testPassword')
assert 'Log out' in str(rv.data)
assert u.get_number_of_all_messages() == 0
db.session.add(
Message(content='_',
time=datetime.utcnow(),
author_id=1,
target_channel=1))
assert u.get_number_of_all_messages() == 1
for _ in range(10):
db.session.add(
Message(content='_',
time=datetime.utcnow(),
author_id=2,
target_channel=1))
assert u.get_number_of_all_messages() == 1
with app.test_client() as c:
rv = login(c, user_2.email, 'testPassword')
assert 'Log out' not in str(rv.data)
rv = login(c, user_2.email, 'testPassword2')
assert 'Log out' in str(rv.data)
assert u.get_number_of_all_messages() == 10
def application_response(app_id,response):
application = Application.query.filter_by().first_or_404()
application.status = response
if response == 'Accepted':
Message(direct_message='You application has been approved, use the enrollment key "thabo" to enroll in the course',tutors=application.tutors,lecturers=current_user.lecture)
else:
Message(direct_message='Unfortunatly your application did not meet the requirements, try applying for a different course, good luck!',tutors=application.tutors,lecturers=current_user.lecture)
db.session.commit()
return redirect(url_for('application.application_details',app_id=app_id))
def add_message(request):
"""
把留言保存到数据库
:param request:
:return:返回响应Response
"""
# 思考：如何知道request是GET还是POST?
# - request是不是对象？ 是
# - request有什么属性和方法？ dir(request)
# print(dir(request))
# print(request.method)
# browser --获得(GET)留言表单---> server
# browser <---把留言表返回给浏览器--- server
# browser ----把填好的表单提交(POST)给server---> server
# ..... server 开始保存数据到数据库
# browser < ------成功或失败的信息返回给浏览器---server
# 如果是GET请求，把留言表单发给用户，让用户填写留言信息
if request.method == 'GET':
return render(request, template_name='msg2.html')
# 如果是POST请求，从请求request中获取提交的内容
if request.method == 'POST':
# print(request.POST)
c = {'msg': '提交成功！'}
# 思考：如果获得提交的数据？
message = request.POST
print(message['name'])
name = message.get('name', None) # gavin '' None False
if not name: # 如果name没有值
c['name_error'] = "用户名不能为空！"
email = message.get('email')
address = message.get('address')
content = message.get('message')
print(name, email, address)
# 思考：如何保存？
# - 首先用Message类创建一个对象
# 方法一：
msg = Message(name=name, email=email, address=address, content=content)
# 方法二：
msg = Message()
msg.name = name
msg.email = email
msg.address = address
msg.content = content
# - 然后，调用对象的保存方法来保存数据
print(dir(msg))
msg.save() # insert into ***
return render(request, template_name='msg2.html', context=c)
def dohandler(self, eventModel):
if eventModel.entityType == EntityType.DYNAMIC:
message = Message(eventModel.actorId, eventModel.entityOwnerId,
'名为 ' + eventModel.dict['name'] + ' 的人评论了你的动态',
MessageType.NOTICE, eventModel.dict['detail'])
else:
message = Message(eventModel.actorId, eventModel.entityOwnerId,
'名为 ' + eventModel.dict['name'] + ' 的人回复了你的评论',
MessageType.NOTICE, eventModel.dict['detail'])
db.session.add(message)
db.session.commit()
def forum_messages(course_code):
current_user.last_message_read_time = datetime.now() # pragma: no cover
db.session.commit() # pragma: no cover
form = MessageForm() # pragma: no cover
forum = Forum.query.filter_by(
course=course_code).first_or_404() # pragma: no cover
course = Course.query.filter_by(
course_code=course_code).first_or_404() # pragma: no cover
ordered_messages = forum.messages_received.order_by(
Message.upvote_count.desc()) # pragma: no cover
if request.method == 'GET': # pragma: no cover
page = request.args.get('page', 1, type=int)
messages = forum.messages_received.paginate(
page, current_app.config['POSTS_PER_PAGE'], False)
next_url = url_for('messages.forum_messages',course_code=course_code ,page=messages.next_num) \
if messages.has_next else None
prev_url = url_for('messages.forum_messages',course_code=course_code, page=messages.prev_num) \
if messages.has_prev else None
if form.validate_on_submit(): # pragma: no cover
myfile = request.files['message_attachment']
if form.message.data == '':
if myfile.filename == '':
return redirect(
url_for('messages.forum_messages',
course_code=course_code))
if myfile.filename == '':
msg = Message(author=current_user,
body=form.message.data,
forum=forum,
upvote_count=0)
else: # pragma: no cover
filename = secure_filename(myfile.filename)
myfile.save(os.path.join(UPLOAD_FOLDER, filename))
msg = Message(author=current_user,
body=form.message.data,
forum=forum,
attachment_name=filename,
upvote_count=0)
db.session.add(msg)
db.session.commit()
return redirect(
url_for('messages.forum_messages', course_code=course_code))
return render_template(
'messages/forum_messages.html',
title='forum messages',
messages=messages.items,
next_url=next_url,
prev_url=prev_url,
form=form,
course_code=course_code,
ordered_messages=ordered_messages) # pragma: no cover
def message_helper(self):
u1 = User.query.filter_by(username="******").first()
u2 = User(username="******", email="*****@*****.**")
db.session.add(u2)
for i in range(6):
msg2 = Message(author=u1, recipient=u2, body="sent test")
msg = Message(author=u2, recipient=u1, body="test")
db.session.add_all([msg, msg2])
db.session.commit()
db.session.flush()
return u1, u2, msg.id
def setUp(self):
super(ChatTestCase, self).setUp()
admin = User(email='*****@*****.**',
nickname='Admin Tester',
github='https://github.com/wangtianxing1010')
admin.set_password('123456')
message1 = Message(body='Test Message 1')
message2 = Message(body='Test Message 2')
message3 = Message(body='Test Message 3')
admin.messages = [message1, message2, message3]
db.session.add(admin)
db.session.commit()
def application_response(app_id,response):
application = Application.query.filter_by(applicaton_id=app_id).first_or_404()# pragma: no cover
application.status = response# pragma: no cover
if response == 'Accepted':# pragma: no cover
message = Message(body=f"Congratulations {application.tutors.user.firstname}. Your application for {application.courses.course_code} has been accepted. The lecturer will contact you regarding enrollment details.",
author=current_user , recipient=application.tutors.user)
else:# pragma: no cover
message = Message(body=f'Unfortunatly your application for {application.courses.course_code} did not meet the admission requirements. Try applying for a different course. Good luck!',
author=current_user , recipient=application.tutors.user)
db.session.add(application)# pragma: no cover
db.session.add(message)# pragma: no cover
db.session.commit()# pragma: no cover
return redirect(url_for('application.application_details',app_id=app_id))# pragma: no cover
def conversation(other):
user = User.query.filter_by(username=other).first_or_404()
form = MessageForm()
if form.validate_on_submit():
language = guess_language(form.message.data)
if language == 'UNKNOWN' or len(language) > 5:
language = ''
msg = Message(author=current_user, recipient=user, body=form.message.data, language=language)
db.session.add(msg)
user.add_notification('unread_message_count', user.new_messages())
db.session.commit()
flash('Your message has been sent.')
return redirect(url_for('main.conversation', other=other))
page = request.args.get('page', 1, type=int)
conversation = current_user.all_messages_with_other(user).paginate(
page, current_app.config['POSTS_PER_PAGE'], False)
next_url = url_for('main.conversation', page=conversation.next_num, other=other) if conversation.has_next else None
prev_url = url_for('main.conversation', page=conversation.prev_num, other=other) if conversation.has_prev else None
if conversation.total % current_app.config['POSTS_PER_PAGE'] == 0:
last_page = conversation.total // current_app.config['POSTS_PER_PAGE']
else:
last_page = conversation.total // current_app.config['POSTS_PER_PAGE'] + 1
last_url = url_for('main.conversation', page=last_page, other=other)
return render_template('messages_with_other.html', conversation=conversation.items,
next_url=next_url, prev_url=prev_url, user=user,
title=user.username + ' - Conversation', form=form, last_url=last_url)
def save_msg():
form = request.form
author = form.get("author")
content = form.get("content")
msg = Message(author=author, content=content, time=datetime.now())
msg.save()
return jsonify(status='success')
def create_message():
"""给其它用户发送私信"""
data = request.get_json()
if not data:
return bad_request('You must post JSON data.')
if 'body' not in data or not data.get('body'):
return bad_request('Body is required.')
if 'recipient_id' not in data or not data.get('recipient_id'):
return bad_request('Recipient id is required.')
user = User.query.get_or_404(int(data.get('recipient_id')))
if g.current_user == user:
return bad_request('You cannot send private message to yourself.')
if user.is_blocking(g.current_user):
return bad_request('You are in the blacklist of {}'.format(
user.username))
message = Message()
message.from_dict(data)
message.sender = g.current_user
message.recipient = user
db.session.add(message)
# 给私信接收者发送新私信通知
user.add_notification('unread_messages_count', user.new_recived_messages())
db.session.commit()
response = jsonify(message.to_dict())
response.status_code = 201
# HTTP协议要求201响应包含一个值为新资源URL的Location头部
response.headers['Location'] = url_for('api.get_message', id=message.id)
return response
def create_message():
"""发送一条私信"""
json_data = request.json
if not json_data:
return bad_request('You must post JSON data')
if 'body' not in json_data and not json_data.get('body'):
return bad_request('body is required')
if 'recipient_id' not in json_data and not json_data.get('recipient_id'):
return bad_request('recipient_id is required')
user = User.query.get_or_404(json_data['recipient_id'])
if g.current_user == user:
return bad_request('You cannot send private message to yourself.')
if user.is_blocking(g.current_user):
return bad_request('You are in the blacklist of {}'.format(user.name if user.name else user.username))
message = Message()
message.from_dict(json_data)
message.sender = g.current_user
message.recipient = user
db.session.add(message)
db.session.commit()
user.add_notification('unread_messages_count',user.new_recived_messages())
response = jsonify(message.to_dict())
response.status_code = 201
response.headers['Location'] = url_for('api.get_message', id=message.id)
return response
def test_get_message(self):
m = Message()
m.content = 'test'
m.add_or_update()
m = Message.find_by_id(m.id)
self.assertEqual(m.content, 'test')
self.assertEqual(m.id, 1)
def test_can_user_read_message(self):
u1_name = 'john'
u1_email = '*****@*****.**'
u2_name = 'alex'
u2_email = '*****@*****.**'
u1 = User(username=u1_name, email=u1_email, password='******')
u2 = User(username=u2_name, email=u2_email, password='******')
db.session.add(u1)
db.session.add(u2)
db.session.commit()
status = 'Accepted'
time = datetime.datetime.utcnow()
m1 = Message(id=random.randint(1000000, 9999999),
first_username=u1_name,
second_username=u2_name,
chat='Hello',
timestamp=time,
chat_by=u1_name)
db.session.add(m1)
db.session.commit()
# john deletes a message with alex
msg = Message.query.filter_by(first_username='******',
second_username='******').first()
msg.read_permission_first_user = False
db.session.commit()
self.assertFalse(Message.can_user_read_message(u1_name, msg.id))
def message_user(id_param):
form = MessageForm()
form['csrf_token'].data = request.cookies['csrf_token']
user = User.query.filter(User.id == current_user.id).first()
user_to_message = User.query.filter(User.id == id_param).first()
def message_info(self):
return {
"id": self.id,
"read": self.read,
"content": self.content,
"recipient_id": self.recipient_id,
"message_sender_id": self.message_sender_id,
"created_at": self.created_at
}
if form.validate_on_submit():
message_data = request.form.get('content')
message = Message(
read=False,
content=message_data,
recipient_id=user_to_message.id,
message_sender_id=user.id,
)
db.session.add(message)
db.session.commit()
return message_info(message)
return "Bad Data"
def follow():
data = {}
user_id = request.values.get('user_id', '', type=str)
idol_id = request.values.get('idol_id', '', type=str)
cancel = request.values.get('cancel', 0, type=int)
user = User.query.get(user_id)
idol = User.query.get(idol_id)
if user and idol:
fan = Fan.query.filter_by(user_id=user_id,
idol_id=idol_id).limit(1).first()
if not fan and not cancel and user_id != idol_id:
follow_message_type = MessageType.query.filter_by(
type='follow').first()
# TODO: follow_message_type Factory
fan = Fan(user_id=user_id, idol_id=idol_id)
db.session.add(fan)
message = Message(follow_message_type, idol, user)
db.session.add(message)
db.session.commit()
elif fan and fan.is_deleted and not cancel:
fan.is_deleted = False
elif fan and cancel:
fan.is_deleted = True
data['status'] = SUCCESS
data['message'] = SUCCESS_MSG
else:
data['status'] = PARAMETER_ERROR
data['message'] = PARAMETER_ERROR_MSG
return jsonify(data)
def send_messages(*args, **kwargs):
try:
sender = User.query.get(kwargs.get('user_id'))
recipients = User.query.filter(User.id != kwargs.get('user_id'))
for user in recipients:
message = Message()
message.body = kwargs.get('body')
# 发送方是自己
message.sender = sender
# 接收方是所有其他用户
message.recipient = user
db.session.add(message)
db.session.commit()
text_body = '''
你好，
这是liyang的博客管理团队发出的群邮件
'''
html_body = '''
<p>你好 {0},</p>
<p>{1}</p>
<p> ----来自于Admin的邮件</p>
'''.format(user.username, message.body)
send_email('[myBlog] 温馨提醒',
sender=app.config['MAIL_SENDER'],
recipients=[user.email],
text_body=text_body,
html_body=html_body,
sync=True)
job = get_current_job() # 当前后台任务
task = Task.query.get(job.get_id()) # 通过任务ID查出对应的Task对象
task.complete = True
db.session.commit()
except Exception:
app.logger.error('群发失败：', exc_info=sys.exc_info())
def newmessage():
if not current_user.is_authenticated:
return redirect(url_for('index'))
form = MessageForm()
if form.validate_on_submit():
s_name = current_user.display_name
s_id = current_user.id
receiver = User.query.filter_by(
username=form.receiver_name.data).first()
r_id = receiver.id
content = form.content.data
msg = Message(body=content,
sender_id=s_id,
sender_name=s_name,
receiver_id=r_id)
db.session.add(msg)
db.session.commit()
flash('Message Sent!')
return redirect(url_for('inbox'))
#else:
#flash('Error creating message. Please try again')
return render_template('newmessage.html',
title='Create Message',
form=form)
def messages(username):
if username == current_user.username:
abort(404)
profile = User.query.filter_by(username=username).first_or_404()
if not current_user.is_connected_to(profile):
return redirect(url_for("profile", username=username))
messages = current_user.get_messages_with(profile).all()
if request.method == 'POST':
if request.form.get("errand") == "updates":
if messages != current_user.get_messages_with(profile).all():
new_messages = dict.fromkeys(x for x in dict.fromkeys(current_user.get_messages_with(profile).all()).keys() if x not in dict.fromkeys(messages).keys()).keys()
messages = current_user.get_messages_with(profile).all()
return json.dumps({'messages': [msg.content for msg in new_messages]})
return json.dumps({'messages': []})
content = request.form.get("content")
if not content:
return json.dumps({'status': 'Text-field required'})
message = Message(content=content, sender=current_user, recipient=profile)
db.session.add(message)
db.session.commit()
return json.dumps({'status': 'Successfully sent', 'message': content})
return render_template('messages.html', profile=profile, messages=messages, enumerate=enumerate, messages_amount=len(messages))
def dohandler(self, eventModel):
message = Message(
-1, eventModel.entityOwnerId, '您刚刚' + eventModel.dict['action'] +
'了名称为 ' + eventModel.dict['orginlname'] + ' 的相册信息',
MessageType.NOTICE, '')
db.session.add(message)
db.session.commit()
def post(self):
'''
添加
'''
args = parse_form.parse_args()
name = args.get('name')
email = args.get('email')
contact = args.get('contact')
info = args.get('info')
site = args.get('site')
ip = request.remote_addr
model_data = Message()
model_data.name = name
model_data.email = email
model_data.contact = contact
model_data.info = info
model_data.ip = ip
model_data.site = site
if model_data.add():
data = {'status': RET.OK, 'msg': 'Success', 'data': model_data}
subject = '您有新的询盘，请注意查收！'
html_body = '<p>姓名：%s</p>' \
'<p>邮箱：%s</p>' \
'<p>联系方式：%s</p>' \
'<p>留言内容：%s</p>' \
'<p>用户来源：%s</p>'% (name, email,contact,info,ip)
_mail = SendMail(subject=subject, html_body=html_body)
_mail.send_email()
return marshal(data, sing_fields)
abort(RET.BadRequest, msg='error')
def test_repr() -> None:
channel = Channel(name='channelName', password='******')
assert channel.__repr__() == "Channel(name='channelName')"
user = User(username='******',
password='******',
email='*****@*****.**')
assert user.__repr__() == "User(name='userName')"
with app.app_context():
db.drop_all()
db.create_all()
db.session.add(user)
db.session.add(channel)
channel_id = Channel.query.first().id
user_id = User.query.first().id
channel_allow_list = ChannelAllowList(user_id=user_id,
channel_id=channel_id,
user_role=UserRole.ADMIN.value)
assert channel_allow_list.__repr__() == \
f'ChannelAllowList(channel_id=1, user_id=1, user_role={UserRole.ADMIN.value})'
time = datetime.utcnow()
message = Message(content='content',
author_id=user_id,
target_channel=channel_id,
time=time)
assert message.__repr__(
) == f"Message(author_id=1, target_channel=1, time={time})"
def user(username):
user = User.query.filter_by(username=username).first_or_404()
message_form = MessageForm()
if message_form.validate_on_submit():
message = Message(author=current_user,
recipient=user,
body=message_form.message.data)
db.session.add(message)
db.session.commit()
user.add_notification('unread_message_count', user.new_messages())
db.session.commit()
flash('Your message has been sent!')
return redirect(url_for('user', username=username))
page = request.args.get('page', 1, type=int)
schemes = user.schemes.order_by(Scheme.timestamp.desc()).paginate(
page, app.config['SCHEMES_PER_PAGE'], False)
next_url = url_for('index',
page=schemes.next_num) if schemes.has_next else None
prev_url = url_for('index',
page=schemes.prev_num) if schemes.has_prev else None
return render_template('user.html',
user=user,
schemes=schemes.items,
next_url=next_url,
prev_url=prev_url,
form=message_form)
def u(username):
messages = None
message_form = MessageForm()
clear_message_form = ClearMessageForm()
user = User.query.filter_by(username=username).first_or_404()
current_user.message_sent = False
current_user.message_removed = False
if user != current_user:
if message_form.validate_on_submit():
message = Message(author=current_user,
recipient=user,
subject=message_form.message_subject.data,
body=message_form.message_textarea.data)
db.session.add(message)
db.session.commit()
current_user.message_sent = True
if user == current_user:
if clear_message_form.validate_on_submit():
message = Message.query.filter_by(
id=clear_message_form.message_id.data).first()
db.session.delete(message)
db.session.commit()
current_user.message_removed = True
messages = current_user.messages_received.order_by(
Message.timestamp.desc())
return render_template("user.html",
user=user,
message_form=message_form,
clear_message_form=clear_message_form,
messages=messages)
def dohandler(self, eventModel):
userid = eventModel.entityId
message = Message(eventModel.actorId, userid,
'名为 ' + eventModel.dict['name'] + ' 的用户关注了你',
MessageType.NOTICE, '')
db.session.add(message)
db.session.commit()
def user(username):
form = MessageForm()
user = User.query.filter_by(username=username).first_or_404()
page = request.args.get('page', 1, type=int)
posts = user.posts.order_by(Post.timestamp.desc()).paginate(
page, current_app.config['POSTS_PER_PAGE'], False)
next_url = url_for('main.user', username=username,
page=posts.next_num) if posts.has_next else None
prev_url = url_for('main.user', username=username,
page=posts.prev_num) if posts.has_prev else None
if form.validate_on_submit():
msg = Message(author=current_user,
recipient=user,
body=form.message.data)
user.add_notification('unread_message_count', user.new_messages())
db.session.add(msg)
db.session.commit()
flash(_('Your message has been sent to {}.'.format(user.username)))
return render_template('user.html',
user=user,
posts=posts.items,
next_url=next_url,
prev_url=prev_url,
form=form,
recipient=username)
