def post(self, reciepent, text):
reciepent = User.get_by_key_name(reciepent)
sender = User.get_by_key_name(self.fb_uid)
chatjoin = ChatJoin.get_chat(sender.fb_uid, reciepent.fb_uid)
message = Message(chatjoin = chatjoin, sender = sender, text = text)
message.put()
chatjoin.put()
chat = Chat(key_name = sender.fb_uid + '|' + reciepent.fb_uid,
chatjoin = chatjoin,
user = sender,
other = reciepent,
date = message.date,
last_message_text = message.text,
read = True)
chat.put()
chat = Chat(key_name = reciepent.fb_uid + '|' + sender.fb_uid,
chatjoin = chatjoin,
user = reciepent,
other = sender,
date = message.date,
last_message_text = message.text,
read = False)
chat.put()
self.send_message(reciepent.fb_uid, {
'type' : 'new-chat',
'chat' : chat,
})
return True
def messages(request, game_id, round_id, thread_id):
thread = Thread.get_by_uid(thread_id)
if thread is None:
raise Http404
if not thread.profile_can_view(request.profile):
return HttpResponse('Unauthorized', status=401)
if request.method == 'GET':
since = request.GET.get('since', None)
return json(Message.get_activities(request.user,
thread,
since=since))
if request.method == 'POST':
if not thread.profile_can_create(request.profile):
return HttpResponse('Unauthorized', status=401)
content = request.POST.get('content', None)
if not content:
return HttpResponse('Method Not Allowed - A message is required', status=405)
# create the new message
game = Game.get_by_uid(game_id)
actor = Role.get_by_profile(game, request.profile)
message = Message(actor=actor,
content=content,
thread=thread)
message.put()
return json(message)
return HttpResponse('Method Not Allowed', status=405)
def _send_message():
data = request.get_json(force=True)
content = data['content']
receiver_pinyin = data['receiver']
receiver = User.query.filter_by(pyname=receiver_pinyin).first()
message = Message(sender_id=current_user.id, content=content, receiver_id=receiver.id)
message.save()
return json.dumps({'info': 'success!'})
def reply_to_message(request, messageID):
if request.method == 'POST':
m = Message(text=request.POST['replyfield'], poster=request.user,
reply_to=get_object_or_404(Message, id=messageID),
issue_id=get_object_or_404(Message, id=messageID).issue.id)
m.save()
response = m.message_json(False)
return JsonResponse(response)
def message(id):
'''profile.message(id)'''
tab = 'message'
user = User.query.get_or_404(id)
if not user.created or user.deleted:
abort(404)
if not current_user.can_access_profile(user=user):
abort(403)
form = MessageForm()
if user.id != current_user.id and form.validate_on_submit():
message = Message(
title=form.title.data,
body_html=sanitize_html(form.body.data),
modified_by_id=current_user.id
)
db.session.add(message)
db.session.commit()
message.send_to(user=user)
db.session.commit()
flash('已向“{}”发送站内信：{}'.format(user.name_email, message.title), category='success')
add_user_log(
user=current_user._get_current_object(),
event='向“{}”发送站内信：{}'.format(user.name_email, message.title),
category='manage'
)
return redirect(url_for(
'profile.message',
id=user.id,
page=request.args.get('page', 1, type=int)
))
if user.is_staff or user.is_suspended_staff:
query = Message.query\
.filter(Message.modified_by_id == user.id)\
.filter(Message.deleted == False)\
.order_by(Message.modified_at.desc())
else:
query = UserMessage.query\
.join(Message, Message.id == UserMessage.message_id)\
.filter(UserMessage.user_id == user.id)\
.filter(Message.deleted == False)\
.order_by(Message.modified_at.desc())
page = request.args.get('page', 1, type=int)
pagination = query.paginate(page, per_page=current_app.config['RECORD_PER_PAGE'], error_out=False)
items = pagination.items
return minify(render_template(
'profile/message.html',
profile_tab=tab,
form=form,
pagination=pagination,
items=items,
user=user
))
def __init__(self, src): Message.__init__(self, src['text'], "TWITTER", src['user']['id_str'] ) # des setters font référence à self._src, c'est embetant... self._src = src self.provider_id = src['id_str'] self.message = self.formatMessage(src) self.author = src['user']['screen_name'] self.avatar = src['user']['profile_image_url'] self.url_entities = src['entities']['urls'] # pourrait etre 'entities' self.links = self.setLinks() self.medias = self.setMedias(src['entities']) self.races = self.setRaces() self.ctime = self.makeDate(src['created_at'])
def commit_message(request):
user = User.objects.get(id=1)
nickname = request.GET.get('nickname')
title = request.GET.get('title')
content = request.GET.get('content')
if nickname == '':
return HttpResponse('昵称不可为空')
elif title == '':
return HttpResponse('标题不可为空')
elif content == '':
return HttpResponse('内容不可为空')
message = Message(user=user, author=nickname, title=title, content=content)
message.save()
return HttpResponse('留言成功')
def message(request):
user = User.objects.get(id=1)
if request.method == 'POST':
nickname = request.POST.get('nickname')
title = request.POST.get('title')
content = request.POST.get('content')
if nickname == '':
return HttpResponse('感谢您的支持! 但昵称不可为空哦！<h2><a href="/">返回主页</a></h2>')
elif title == '':
return HttpResponse('感谢您的支持! 但标题不可为空哦！<h2><a href="/">返回主页</a></h2>')
elif content == '':
return HttpResponse('感谢您的支持! 但内容不可为空哦！<h2><a href="/">返回主页</a></h2>')
#print nickname
message = Message(user=user, author=nickname, title=title, content=content)
message.save()
return HttpResponse('留言成功，感谢您的支持! <h2><a href="/">返回主页</a></h2>')
else:
return HttpResponse('留言失败感谢您的支持! <h2><a href="/">返回主页</a></h2>')
def build_new_messages(account, client):
print 'search', None, account.search
result, data = client.uid('search', None, account.search)
data = " ".join(data)
uids = data.split()
new_uids = get_new_uids(account, client, uids)
if not new_uids:
return []
print 'fetch', ",".join(new_uids), 'RFC822'
result, data = client.uid('fetch', ",".join(new_uids), 'RFC822')
new = []
for parts in data:
if len(parts) != 2:
continue
envelope, raw = parts
uid = get_id_from_envelope(envelope)
m = Message(account=account, uid=uid)
m.set_message(email.message_from_string(raw))
m.save()
new.append(m)
return new
def admin_index_view():
stats = {'all_active_users': User.count(),
'today_active_users': User.today_all_active_users(),
'all_chats': Chat.count(),
'today_chats': Chat.today_new_count(),
'all_messages': sum(u.msg_count for u in UserStat.all()),
'today_messages': Message.today_all_count(),
'last_chats': Chat.last_chats_list()}
return render_template('admin/index.html',
stats=stats,
entities=Entity.generate_list()[0],
format_time=format_time)
def post_message(request, issueID):
if request.method == 'GET':
messages = Message.objects.filter(issue=issueID)
response = {}
response['messages'] = []
if request.user.is_authenticated():
votes = MessageVote.objects.filter(user=request.user)
else:
votes = None
for m in messages:
message = m.message_json()
if votes is not None:
message['liked'] = votes.filter(message=m).count() > 0
else:
message['liked'] = False
response['messages'].append(message)
for m in messages:
replies = Message.objects.filter(reply_to=m)
response['messages'].append({'replies':replies})
return JsonResponse(response)
elif request.user is None or request.user.is_anonymous():
return HttpResponseForbidden('Please login before posting')
elif request.method == 'POST':
issue = Issue.objects.get_or_create(id=issueID)
if issue[1] is True:
issue[0].save()
logging.info("Created object with id %s" % issueID)
m = Message(text=request.POST['messagefield'], poster=request.user, issue_id=issueID)
m.save()
response = m.message_json()
return JsonResponse(response)
else:
return HttpResponseBadRequest("Only POST and GET methods are allowed")
def create_message(from_user_id, to_user_id, content):
message = Message()
message.from_user_id = from_user_id
message.receive_user_id = to_user_id
message.date = datetime.now()
message.content = content
status = EnumValues.find_one_by_code(const.MESSAGE_STATUS_UNREAD)
message.status_id = status.id
return message
def make_base_objects():
u1 = User(username='******', email='123')
u2 = User(username='******', email='1234')
u1.set_password('12345')
u2.set_password('12345')
r = Room(name='test')
u1.rooms.append(r)
u2.rooms.append(r)
for i in range(10):
username = random.choice(['Andrey', 'Alsu'])
m = Message(text=f'test_text{i}', username=username, room_id=r.id)
db.session.add(m)
db.session.add(u1)
db.session.add(u2)
db.session.add(r)
db.session.commit()
def send_message(recipient):
user = User.query.filter_by(username=recipient).first_or_404()
form = MessageForm()
if form.validate_on_submit():
msg = Message(author=current_user,
recipient=user,
body=form.message.data)
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.user', username=recipient))
return render_template('send_message.html',
title=_('Send Message'),
form=form,
recipient=recipient)
def sendmessage(request):
email_session = request.session.get('email')
account = Account.objects.select_related().get(login__email=email_session)
MyMsgForm = SendMessageForm(request.POST)
if request.method == "POST":
if MyMsgForm.is_valid():
message = MyMsgForm.cleaned_data['message']
to = MyMsgForm.cleaned_data['to']
subject = MyMsgForm.cleaned_data['subject']
msg = Message()
msg.message = message
msg.subject = subject
msg.message_from = account
msg.message_to = Account.objects.select_related().get(
login__email=to)
msg.date = datetime.datetime.now()
msg.save()
return redirect('/message/')
def send_message(recipient):
user = User.query.filter_by(username=recipient).first_or_404()
form = MessageForm()
if form.validate_on_submit():
msg = Message(author=current_user,
recipient=user,
body=form.message.data)
db.session.add(msg)
user.add_notification('unread_message_count', user.new_messages())
db.session.commit()
flash("Your message was successfully delivered.")
return redirect(url_for('main.user', username=recipient))
return render_temlpate('send_message.html',
title="Private Message",
form=form,
recipient=recipient)
def send_message():
response = request.get_json()
status = {"status": "something is wrong!"}
if response['author'] != '':
u = User.query.filter_by(username=response['author']).first_or_404()
message = TextBlob(response['data']['text'])
m = Message(client_id=u.id,
text=response['data']['text'],
polarity=message.sentiment.polarity,
subjectivity=message.sentiment.subjectivity)
db.session.add(m)
db.session.commit()
status['status'] = "OK"
return jsonify(status)
def send_message(recipient):
user = User.query.filter_by(username=recipient).first_or_404()
form = MessageForm()
if form.validate_on_submit():
msg = Message(author=current_user,
recipient=user,
body=form.message.data)
db.session.add(msg)
user.add_notification('unread_message_count', user.new_messages())
db.session.commit()
flash('Your message has been sent.', category='success')
return redirect(url_for('user', username=recipient))
return render_template('send_message.html',
title='Send Message',
form=form,
recipient=recipient,
refresh=app.config['PAGE_REFRESH'])
def list_msg():
page = request.args.get("page")
searchValue = request.args.get("searchValue")
if searchValue:
paginator = Message.objects(
content__contains=searchValue).order_by('-time').paginate(
page=int(page), per_page=5)
else:
paginator = Message.objects.order_by('-time').paginate(page=int(page),
per_page=5)
pager = {
'page': paginator.page,
'pages': paginator.pages,
'messages': [m.to_json() for m in paginator.items]
}
return jsonify(status="success", pager=pager)
def websocket(u=None):
global user_socket_dict
user_socket = request.environ.get('wsgi.websocket')
if not user_socket:
return fail('Websocket required')
from_id = u.id
user_socket_dict[str(from_id)] = user_socket
print("User ", from_id, " connected.")
while True:
try:
message_received = user_socket.receive()
if message_received is None:
continue
message_received = json.loads(message_received)
to_id = message_received.get('to_id', None)
content_type = message_received.get('content_type', None)
content = message_received.get('content', None)
if to_id is None or content is None or content is None:
continue
if content_type == 'IMAGE':
r = ImageNameRelation.query.filter(ImageNameRelation.raw_name == content).first()
if r is None:
continue
content = filename_2_url(r.generated_name,'image')
message_send = {
'from_id': from_id,
'name': u.nickname,
'content_type': content_type,
'content': content
}
m = Message(
from_id=from_id, to_id=to_id,
content_type=content_type, content=content
)
db.session.add(m)
db.session.commit()
to_user_socket = user_socket_dict.get(str(to_id), None)
if to_user_socket is not None:
to_user_socket.send(json.dumps(message_send))
except WebSocketError as e:
print(e)
print("User ", from_id, " disconnected.")
user_socket_dict.pop(str(from_id))
break
return fail('Websocket end')
def test_run_badrequest(self):
""" Delete a message that is deleted on the telegram api <- BadRequest """
self.test_bot.delete_message = MagicMock(
side_effect=BadRequest("Message not found"))
# Add a message to the db
message = Message(user_id="3", chat_id="3", message_id="3")
db.session.add(message)
db.session.commit()
self.test_worker.cleanup()
self.test_bot.delete_message.assert_called()
self.test_bot.delete_message.assert_called_with(chat_id="3",
message_id="3")
message = Message.query.filter_by(user_id="3",
chat_id="3",
message_id="3").one_or_none()
assert message is None
def send_feedback():
form_data = request.form
print(request.form)
feedback = form_data.get('feedback', None)
error = ''
if not feedback:
error = 'Please specify feedback to send'
if error:
return render_template('account_area/account_area.html', error=error)
else:
new_message = Message(message=feedback,
from_user=current_user.username)
db.session.add(new_message)
db.session.commit()
return render_template('account_area/account_area.html')
def sent_private_message(data):
hash_id = data.get('id')
msg_obj = Message.get(hash_id)
recipient = User.query.get(msg_obj.recipient_id)
sender = User.query.get(msg_obj.sender_id)
msg = {
'position' : 'left',
'date' : msg_obj.timestamp.isoformat() + 'Z',
'status' : 'received',
'text' : msg_obj.body,
'type' : 'text',
'id' : msg_obj.hash_id,
'recipient_id': recipient.hash_id,
'sender_id' : sender.hash_id,
'channel_id' : msg_obj.channel.hash_id
}
emit('new_private_message', msg, broadcast=True)
def send_message(recipient):
user = User.query.filter_by(
username=recipient).first_or_404() # pragma: no cover
form = MessageForm() # pragma: no cover
if form.validate_on_submit(): # pragma: no cover
msg = Message(author=current_user,
recipient=user,
body=form.message.data)
db.session.add(msg)
db.session.commit()
flash('Your message has been sent.')
return redirect(
url_for('tutor.tutor_details', id_number=user.tutor.id_number))
return render_template('messages/send_message.html',
title='Send Message',
form=form,
recipient=recipient) # pragma: no cover
def create_all():
db.create_all()
user = User(1761161690, '*****@*****.**', 'CITADEL', 1, None, None,
None, None)
db.session.add(user)
user = User(-1235243292, '*****@*****.**', 'Company you need', 0, None,
None, None, None)
db.session.add(user)
auth = Auth(1761161690, -1861353340)
db.session.add(auth)
auth = Auth(-1235243292, -1861353340)
db.session.add(auth)
tagAndroid = Tag('Android')
tagWeb = Tag('Web')
tagAI = Tag('AI')
tagB = Tag('B2B')
tagC = Tag('B2C')
tagG = Tag('B2G')
tagEd = Tag('Education')
db.session.add_all([tagAndroid, tagAI, tagB, tagEd, tagWeb, tagC, tagG])
db.session.commit()
project = Project(name='RISE',
contact=1761161690,
contact_name='CITADEL',
description_long='The best startup platform ever',
cost='100 000',
deadlines='1 месяц',
website='http://bestApp.ever/RISE')
project.tags.extend([tagAndroid, tagB, tagC, tagG])
db.session.add(project)
project1 = Project('CITADEL Education', 1761161690, 'CITADEL',
'The best education platform ever', '110 000 000',
'2 месяца', 'http://bestApp.ever/Education')
project1.tags.extend([tagAI, tagEd, tagWeb])
db.session.add(project1)
chat = Chat(1761161690, -1235243292, "Hi there!")
db.session.add(chat)
message = Message(1, 1761161690, -1235243292, "Hi there!", "0.0.00 00:00")
db.session.add(message)
db.session.commit()
return str(200)
def post(self, request, format=None):
try:
to_user = Chatter.objects.get(email=request.DATA['username'])
from_user = Chatter.objects.get(email=request.DATA['userfrom'])
msg = Message(msg_from=from_user,
msg_to=to_user,
text=request.DATA['message'],
created_at=timezone.now())
# If recipient has a token stored, send them a push notification
if not to_user.device_token == Chatter.NO_TOKEN:
print "Device token found, sending push"
print to_user.device_token
# Build the payload
push_dict = {}
notification_dict = {}
ios_dict = {}
android_dict = {}
push_dict["platform"] = "ios,android"
push_dict["tokens"] = [to_user.device_token]
notification_dict["alert"] = "{0} says: \n{1}".format(
from_user.full_name, msg.text)
ios_dict["badge"] = 2
ios_dict["sound"] = "ping.aiff"
notification_dict["ios"] = ios_dict
notification_dict["android"] = android_dict
push_dict["notification"] = notification_dict
# Build the POST
# curl -H "Content-Type: application/json" -H "X-Ionic-Applicaton-Id: 92e87c0b" -H "X-Ionic-API-Key: c34a09a9d3a5fbbdda83078daef693806d15d3435b2996ee" -d '{"platform": "ios","tokens":["6f6609366d7fe668ca2ed2dde38dfbe0cc15f1c82930ce5c7972827190e278df"],"notification":{"alert":"Basic push!","ios":{"badge":4,"sound":"ping.aiff"}}}' https://push.ionic.io/api/v1/push
try:
url = "https://push.ionic.io/api/v1/push"
req = urllib2.Request(url, data=json.dumps(push_dict))
req.add_header("Content-Type", "application/json")
req.add_header("X-Ionic-Application-Id", "92e87c0b")
req.add_header(
"X-Ionic-API-Key",
"c34a09a9d3a5fbbdda83078daef693806d15d3435b2996ee")
resp = urllib2.urlopen(req)
print resp.fp.read()
except urllib2.HTTPError, e:
print e.fp.read()
else:
def user(username):
user = User.query.filter_by(username=username).first_or_404()
page = request.args.get('page', 1, type=int)
if user == current_user:
form = EditProfileForm(current_user.username)
if form.validate_on_submit():
current_user.username = form.username.data
current_user.about_me = form.about_me.data
db.session.commit()
flash(_('Your changes have been saved.'))
return redirect(url_for('main.user', username=username))
elif request.method == 'GET':
form.username.data = current_user.username
form.about_me.data = current_user.about_me
else:
form = MessageForm()
if form.validate_on_submit():
msg = Message(author=current_user,
recipient=user,
body=form.message.data)
db.session.add(msg)
user.add_notification('unread_message_count', user.new_message())
db.session.commit()
flash(_('Your message has been sent.'))
return redirect(url_for('main.user', username=username))
messages = current_user.messages_received \
.order_by(Message.timestamp.desc()) \
.limit(2)
posts = current_user.posts.paginate(page,
current_app.config['POSTS_PER_PAGE'],
False)
next_url = url_for('main.user', username=user.username, page=posts.next_num) \
if posts.has_next else None
prev_url = url_for('main.user', username=user.username, page=posts.prev_num) \
if posts.has_prev else None
return render_template('user.html',
form=form,
user=user,
messages=messages,
posts=posts.items,
next_url=next_url,
prev_url=prev_url)
def forge(count):
"""Generate fake messages."""
from faker import Faker
db.drop_all()
db.create_all()
fake = Faker("zh_CN")
click.echo('Working...')
for i in range(count):
message = Message(name=fake.name(),
body=fake.sentence(),
timestamp=fake.date_time_this_year())
db.session.add(message)
db.session.commit()
click.echo('Created %d fake messages.' % count)
def index():
user = {'nickname': 'Luis'}
form = MessageForm()
if form.validate_on_submit():
m = Message(author=form.author.data, body=form.body.data)
db.session.add(m)
db.session.commit()
return redirect('/')
messages = Message.query.all()
return render_template('index.html',
title='Mi primera aplicación',
user=user,
messages=messages,
form=form)
def forge(count):
"""generate fake messages"""
from faker import Faker
db.drop_all()
db.create_all()
fake = Faker()
click.echo("generating messages..")
for i in range(count):
message = Message(name=fake.name(),
body=fake.sentence(),
timestamp=fake.date_time_this_year())
db.session.add(message)
db.session.commit()
click.echo("created %d fake messages." % count)
def message(page=None):
messageForm = MessageForm()
if messageForm.validate_on_submit():
data = messageForm.data
message = Message(content=data['content'])
db.session.add(message)
db.session.commit()
flash('留言成功！', 'okey')
return redirect(url_for('home.message', page=1))
if page == None:
page = 1
pageData = Message.query.order_by(Message.addTime.desc()).paginate(
page=page, per_page=10)
msgcount = Message.query.filter(Message.id).count()
return render_template('home/message.html',
form=messageForm,
pageData=pageData,
msgcount=msgcount)
def send_message():
data = request.form
msg = Message(time=datetime.datetime.now(),
name=data['name'],
color=data['color'],
text=data['text'])
db.session.add(msg)
db.session.commit()
message = {
'time': datetime.datetime.now(),
'name': data['name'],
'color': data['color'],
'text': data['text']
}
socketio.emit('new_message', {'data': json.dumps(message)},
broadcast=True,
namespace='/momoru.messages')
return 'ok'
def upload_file():
if request.method == 'POST':
file = request.files['file']
if file and Files.allowed_file(file.filename):
filename = secure_filename(file.filename)
file.save(
os.path.join(current_app.config['UPLOAD_FOLDER'], filename))
admin = User.query.filter_by(username='******').first()
mess = Message(author=admin,
receiver=current_user,
body=_('You uploaded a file: %(filename)s',
filename=filename))
db.session.add(mess)
db.session.commit()
flash(_('your file have been upload.'))
# return redirect(url_for('uploaded_file', filename=filename))
return redirect(url_for('main.messages'))
return render_template('upload.html', title=_('Upload files.'))
def post(self):
"""
Add message
"""
data = request.json
if Message.query.filter_by(title=data['title']).first() is not None:
abort(400, error='Title already exist')
m = Message(
title=data['title'],
body=data['body']
)
db.session.add(m)
db.session.commit()
return m
def add_message():
text = request.form['text']
end_date_time = request.form['end_date']
start_date = datetime.now().strftime("%Y-%m-%d")
if not text:
flash(_("Text не заполнен"))
elif not end_date_time:
flash(_("Окончание работы не установлен"))
else:
new_note = Message(text=text,
start_date=start_date,
end_date=end_date_time,
status="В ожидании",
user_id=current_user.id)
db.session.add(new_note)
db.session.commit()
return redirect(url_for('add_note'))
def create_view():
json_data = request.get_json()
if not json_data:
return return_non_success_json(400, {'message': 'No input data provided'})
# Validate and deserialize input
message_schema = MessageSchema(only=('recipient_address', 'sender_address', 'subject', 'body'))
try:
data = message_schema.load(json_data)
except ValidationError as err:
return return_non_success_json(422, err.messages)
message = Message(**data.data)
db_session.add(message)
db_session.flush()
db_session.commit()
return jsonify({'messages': 'ok'})
def cancel_by_chef(dish_id):
dish = Dish.query.filter_by(id=int(dish_id)).first()
orders = Order.query.filter_by(dish=dish).all()
if request.method == 'POST':
if request.form['submit_button'] == 'Yes':
for order in orders:
notice = "Dear user %s, your order for dish %s has been cancelled by the chef. Please contact the chef for further information." % (
order.buyer.username, dish.dish_name)
msg = Message(author=None, recipient=order.buyer, body=notice)
db.session.add(msg)
order.buyer.add_notification('unread_message_count',
order.buyer.new_messages())
db.session.delete(order)
db.session.delete(dish)
db.session.commit()
flash("You have deleted this dish.")
return redirect(url_for('user', username=current_user.username))
return render_template('confirm_cancel.html')
def register():
specialty2 = session.get('specialty')
if current_user.is_authenticated:
return redirect(url_for('main.index'))
form = RegistrationForm()
if form.validate_on_submit():
user = User(username=form.username.data, email=form.email.data)
user.set_password(form.password.data)
msg = Message(author=user, recipient=user,
body="Welcome to Matchtest0912! Application is currently under development.")
db.session.add(msg)
db.session.add(user)
db.session.commit()
flash(_('Congratulations, you are now a registered user!'))
login_user(user)
return redirect(url_for('main.index'))
return render_template('auth/register.html', specialty2=specialty2, title=_('Register'),
form=form)
def contactProcess(id):
match = Matchmake.query.get(request.form.get("id"))
if not match.contact:
flash(
"This entry has requested not to be contacted through the team portal",
"warning",
)
return redirect(url_for("matchmake.index"))
if "message" not in request.form or request.form.get("message") == "":
flash(
"You haven't entered a message to send",
"warning",
)
return redirect(url_for("matchmake.contact"), id=match.id)
message = request.form.get("message")
save = Message(sent_from_id=current_user.entry.id,
sent_to_id=match.entry.id,
message=message)
db.session.add(save)
db.session.commit()
send = sendmail(
match.entry.contact_email,
"Kohoutek Matchmaker",
"matchmake-contact",
entry_name=current_user.entry.name,
message=message.split("\n"),
reply_link=match.entry.portal_link("matchmake.contact",
id=current_user.entry.id),
)
if send.status_code == 200:
flash(f"Your message has been sent to { match.entry.name }", "success")
else:
flash(
f"There was an error sending your message to { match.entry.name }",
"warning",
)
return redirect(url_for("matchmake.index"))
def contact():
form = ContactUsForm()
if form.validate_on_submit():
message = Message(name=form.name.data,
email=form.email.data,
phone=form.phone.data,
city=form.city.data,
state=form.state.data,
subject=form.subject.data,
content=form.content.data)
db.session.add(message)
db.session.commit()
flash('Your message has been sent.', 'success')
send_application_submission_confirmation(
form.email.data, "*****@*****.**", "",
"d-91e54bb8d19b473ba12dac4dbe04c0d0")
send_contact_info(form, "d-138e4074de7c49ea9dde946259d49777")
return redirect(url_for('index'))
return render_template('contact.html', title='Contact Us', form=form)
def new_message(message_body):
message = Message(author=current_user._get_current_object(),
body=message_body['body'],
room_name=message_body['room_name'],
timestamp=datetime.utcnow())
db.session.add(message)
db.session.commit()
# send to sender it self
emit(
'new message', {
'message_html':
render_template(
'chat/_message.html', message=message, mode=0, flag=0),
'message_body':
message_body,
'room_name':
message_body['room_name'],
'gravatar':
current_user.gravatar,
'username':
current_user.username,
'user_id':
current_user.id
})
# send to other one
emit('new message', {
'message_html':
render_template('chat/_message.html', message=message, mode=0, flag=1),
'message_body':
message_body,
'room_name':
message_body['room_name'],
'gravatar':
current_user.gravatar,
'username':
current_user.username,
'user_id':
current_user.id
},
to=message_body['room_name'],
skip_sid=request.sid)
def get_response(msg):
"""
you can place your mastermind AI here
"""
message = Message(msg)
db.session.add(message)
db.session.commit()
parts = msg.split(".")
out = "logged %s"%message
if parts[0].lower() == "log":
type = parts[1]
value = None
if len(parts) > 2:
value = parts[2]
kpi = KPI(type, value)
db.session.add(kpi)
db.session.commit()
out = "created %s kpi with value %s"%(type, value)
return out
def test_count_messages(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(first_username=u1_name,second_username=u2_name,chat='Hello',timestamp=time,chat_by=u1_name)
m2 = Message(first_username=u1_name,second_username=u2_name,chat='Hello',timestamp=time,chat_by=u1_name)
m3 = Message(first_username=u2_name,second_username=u1_name,chat='Hello',timestamp=time,chat_by=u2_name)
db.session.add(m1)
db.session.add(m2)
db.session.add(m3)
db.session.commit()
self.assertEqual(Message.count_messages(u1_name,u2_name), 3)
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 send():
if request.method == "GET":
user_id = request.args.get('user_id')
if user_id:
sendto = User.query.get(user_id)
form = NewMessageForm(sendto = sendto.username)
else:
form = NewMessageForm()
#form.sendto.errors.append( u'没有这个用户')
if request.method == "POST":
form = NewMessageForm()
if form.validate_on_submit():
# convert username to user id
you = User.query.filter_by(username=form.sendto.data).first()
if you and you.id != current_user.id:
# one for sender outobx
m1 = Message( owner = current_user, sender = current_user,
receiver = you,
subject = form.subject.data,
content = form.content.data)
m1.save()
# another one for receiver inbox
m2 = Message( owner = you, sender = current_user,
receiver = you,
subject = form.subject.data,
content = form.content.data)
m2.save()
#
return redirect(url_for('message.outbox'))
else:
if not you:
form.sendto.errors.append( u'没有这个用户')
else:
form.sendto.errors.append( u'你不能给自己发信息')
# end if
return render_template( 'message/send.html',
title = u'发送信息', form = form,
user = current_user )
def reply(message_id):
message = Message.query.get_or_404(message_id)
if not message:
flash(u"未发现信息: %s" % id)
return redirect(url_for('message.inbox'))
if message.owner_id != current_user.id:
flash(u"你没有权限回复该消息")
return redirect(url_for('message.inbox'))
if request.method == "GET":
# compose repily message content
reply = "\n".join(map(lambda line:"> "+line, message.content.split("\n")))
content = "在 %s, %s 写:\n%s" %(message.dateshow, message.sender.username, reply)
form = ReplyMessageForm(subject="Re:"+message.subject, content=content)
if request.method == "POST":
form = ReplyMessageForm()
if form.validate_on_submit():
m1 = Message( owner = message.receiver, sender = message.receiver,
receiver = message.sender,
subject = form.subject.data,
content = form.content.data)
m1.save()
m2= Message( owner = message.sender, sender = message.receiver,
receiver = message.sender,
subject = form.subject.data,
content = form.content.data)
m2.save()
url = url_for('message.outbox')
return redirect(url)
return render_template( 'message/reply.html', tilte = u'回复信息',
message = message, form = form, user = current_user)
def group(chat_hash):
chat = Chat.where('hash', chat_hash).first()
if chat:
cid = chat.cid
# Get chat statistics
chat_stats = db.select('(SELECT * FROM chat_stats '
'WHERE cid = "{}" '
'ORDER BY id DESC LIMIT 21) '
'ORDER BY id ASC'.format(cid))
# Chat title
chat_title = chat.title
# Bot add date, dd.mm.yy
add_date = datetime.fromtimestamp(chat.add_time).strftime('%d.%m.%y')
# Today messages NOT USED YET
today_messages = Message.today_chat_count(cid)
# All number of users
all_users = Chat.all_chat_users(cid)
# Today active users
active_users = Chat.today_chat_users(cid)
# Last update
last_update = datetime.fromtimestamp(chat_stats[-1].last_time).strftime('%d.%m.%y (%H:%M)')
# Link for public chats
public_link = chat.public_link
average_users = 0
chart = {'labels': [], 'msg_values': [], 'users_values': []}
# Charts generator
i = 0
for chat in chat_stats:
average_users += chat.users_count
# Dates, dd/mm
d = datetime.fromtimestamp(chat.last_time).strftime('%d')
chart['labels'].append(str(d))
chart['msg_values'].append(chat.msg_count)
chart['users_values'].append(chat.users_count)
i += 1
# Average number of users
average_users = round(average_users / i)
# Generating user list
users = []
user_stats = UserStat.where('cid', cid).order_by('msg_count', 'desc').limit(50).get().all()
for ustat in user_stats:
user = User.get(ustat.uid)
users.append({'name': user.fullname,
'msg_count': ustat.msg_count,
'uid': ustat.uid,
'public': user.public})
# Generating entities
entities = Entity.generate_list(cid)
return render_template('group.html',
page_title='{} - Confstat'.format(chat_title),
chat_title=chat_title,
add_date=add_date,
today_messages=today_messages,
all_users=all_users,
active_users=active_users,
average_users=average_users,
chart=chart,
users=users,
entities=entities[0],
urls=entities[1],
last_update=last_update,
public_link=public_link)
else:
return redirect('/')
def save_msg():
m = Message(author="defshine", content="my first msg",)
m.save()
def post(self):
data = request.form
m = Message.create(message=data.get("message"))
return redirect(request.headers["REFERER"])
def join(data):
room = data['dialog_id']
message = Message(data['sender_id'], data['recipient_id'], data['text'])
db.session.add(message)
db.session.commit()
emit('message', {'message':message.json(),'sender_id':data['sender_id']}, broadcast=True, room=room)
def userpage(request, user_id):
tag_user = User.objects.all()
if request.method == "POST":
income_title = request.POST['title']
income_text = request.POST['text']
if income_title and income_text:
message = Message()
message.author = request.user
message.date = datetime.datetime.now()
message.title = income_title
message.text = income_text
message.save()
user_id = int(user_id)
current_user_id = request.session['member_id']
current_user = User.objects.get(id=current_user_id)
page_owner = User.objects.get(id=user_id)
message = Message.objects.filter(author=page_owner).order_by('-id')
owner_person = Person.objects.get(user=page_owner)
current_person = Person.objects.get(user=current_user)
subscribings_user = Person.get_following(current_person)
subscribers_user = Person.get_followers(current_person)
subscribings_owner = Person.get_following(owner_person)
subscribers_owner = Person.get_followers(owner_person)
condition=False
i=0
for subscribings in subscribings_user:
if page_owner.id != subscribings.user.id:
i += 1
if i == len(subscribings_user):
condition=True
last_message=datetime.datetime.now()
for one in message:
last_message=one.date
if current_user_id == user_id:
message = Message.objects.filter(author=current_user).order_by('-id')
mesform = MessageForm()
last_message=datetime.datetime.now()
for one in message:
last_message=one.date
return render(request, 'userpage.html', {'mesform': mesform,
'message': message,
'page_owner': page_owner,
'cur_user_id': current_user_id,
'subscribings_user': subscribings_user,
'subscribers_user': subscribers_user,
'last_message': last_message,
'tag_user': tag_user}, )
else:
return render(request, 'user.html', {'message': message,
'page_owner': page_owner,
'cur_user_id': current_user_id,
'subscribings_owner': subscribings_owner,
'subscribers_owner': subscribers_owner,
'subscribings_user': subscribings_user,
'condition': condition,
'last_message': last_message,
'tag_user': tag_user}, )
