def callback(bot: telegram.Bot, update: telegram.Update):
if settings.DEBUG:
logger.debug('update: %s', update)
reply_markup = get_reply_markup()
text = format_text(update.message.from_user, update.message.caption)
kwargs = dict(chat_id=update.message.chat_id,
reply_markup=reply_markup,
caption=text)
if update.message.photo:
bot_msg = bot.send_photo(**kwargs,
photo=update.message.photo[-1].file_id)
elif update.message.video:
bot_msg = bot.send_video(**kwargs, video=update.message.video.file_id)
elif update.message.document:
bot_msg = bot.send_document(**kwargs,
document=update.message.document.file_id)
else:
return
try:
with db:
Message.create(message_tg_id=bot_msg.message_id,
chat_tg_id=update.message.chat_id,
user_tg_id=update.message.from_user.id)
bot.delete_message(update.message.chat_id, update.message.message_id)
except Exception:
logger.exception('exception while adding message %s', update)
async def log_message_add(self, message):
if message.author.bot:
return
Message.create(id=message.id,
author_id=message.author.id,
content=message.content)
def submit():
subtype = request.form.get("type")
content = request.form.get("content")
if not content:
flash("必须输入内容")
return redirect(url_for("main.main_page"))
user_id = get_id()
if subtype == "captcha":
challenge = request.form[gt.FN_CHALLENGE]
validate = request.form[gt.FN_VALIDATE]
seccode = request.form[gt.FN_SECCODE]
status = session[gt.GT_STATUS_SESSION_KEY]
if status:
result = gt.success_validate(challenge, validate, seccode, user_id)
else:
result = gt.failback_validate(challenge, validate, seccode)
if not result:
flash("验证失败请重试")
return redirect(url_for("main.main_page"))
r.delete("needtest")
Message.create(user_id=user_id, message=content)
return redirect(url_for("main.main_page"))
if r.exists(user_id):
r.set("needtest", 1)
flash("短时间内提交过多，请验证后发表")
return redirect(url_for("main.main_page"))
else:
pipe = r.pipeline(transaction=True)
r.incr(user_id, 1)
r.expire(user_id, 5)
pipe.execute()
Message.create(user_id=user_id, message=content)
return redirect(url_for("main.main_page"))
def setUp(self):
self.n1, self.n2 = uuid.uuid4().hex, uuid.uuid4().hex
self.k1, self.k2 = fakePublicKey(), fakePublicKey()
self.u1 = User.create(self.n1, self.k1)
self.u2 = User.create(self.n2, self.k2)
self.m1 = Message.create(self.u1, self.u2, 'u1->u2')
self.m2 = Message.create(self.u2, self.u1, 'u2->u1')
self.m3 = Message.create(self.u1, self.u2, 'u1=>u2')
def seed_test_db():
""" Seed the database for testing purpose """
from models import Post, Message
create_user('root', 'root', '*****@*****.**', True, 'roototpsecret')
create_user('foo', 'mypassword', '*****@*****.**', False, 'foootpsecret')
Post.create(1, 'My news', None)
Message.create(2, 1, 'My message', None)
def post(self):
data = ping_parser.parse_args()
dt = datetime.datetime.utcnow()
listener = Listener.get(Listener.key == data["key"])
if listener.enable:
Message.create(listener=listener, data="PING", timestamp=dt)
return {}, 200
return {}, 403
def post(self):
data = update_parser.parse_args()
dt = datetime.datetime.utcnow()
listener = Listener.get(Listener.key == data["key"])
if listener.enable:
Message.create(listener=listener, data=data["data"], timestamp=dt)
msg = f"{listener.description} listener new message:\n{data['data']}"
self.notify(listener.chat_id, msg)
return {}, 200
return {}, 403
def apply(self, *args, **kwargs):
db_conv = Conversation.get(Conversation.conv_id == kwargs.get('conversation_id'))
db_author = User.get(User.gaia_id == kwargs.get('author'))
timestamp = kwargs.get('timestamp')
url_matches = self._url_pattern.match(kwargs.get('message'))
if url_matches:
urls = url_matches.groups()
for url in urls:
if url:
Message.create(content=url, conversation=db_conv, author=db_author, message_type=2, date_created=timestamp)
def ajax_message():
Message.create(user_id=session['user_id'],
content=request.form["message_text"])
message = Message.get(Message.content == request.form["message_text"])
message_info = session['first_name'] + " " + session['last_name'] + " - "
message_info += message.created_at.strftime("%B %d %Y")
message_dict = {
"message": message.content,
"message_info": message_info,
"message_id": message.id,
}
return jsonify(message_dict)
def ajax_message():
Message.create(
user_id=session['user_id'],
content=request.form["message_text"]
)
message = Message.get(Message.content == request.form["message_text"])
message_info = session['first_name'] + " " + session['last_name'] + " - "
message_info += message.created_at.strftime("%B %d %Y")
message_dict = {
"message": message.content,
"message_info": message_info,
"message_id": message.id,
}
return jsonify(message_dict)
def send_message():
""" sending an sms message to a phone number,
required body fields:
{
"email":"<email here>",
"to":"972+<israeli mobile phone number>",
"password":"******"
"message":"<message here..."
}
returned
{
"message": "messgae has been sent from <email> to <to>, your current balance is <current balance>"
}
"""
# simple input validation using marshmallow schemas
json_data = request.get_json()
if not json_data:
return make_response(jsonify({'message': 'No input data provided'}), 400)
try:
data = send_message_schema.load(json_data)
except ValidationError as err:
return make_response(jsonify({'errors': err.messages}), 422)
# find the user, validate password and check its account for active
user = User.select().where(User.email==data['email']).first()
if not user:
return make_response(jsonify({"message": "user account not valid, check email"}), 403)
if user.verify_password(data['password']):
if not user.is_verfied:
return make_response(jsonify({"message": "user account is not verified, make sure your account is verified before sending messages"}), 403)
if user.current_balance < user.plan.message_cost:
return make_response(jsonify({"message": "user credit is not suffiecient, your balance is {} and message cost is {}".format(user.current_balance, user.plan.message_cost)}), 403)
else:
new_current_balance = user.current_balance - user.plan.message_cost
client.send_message({
'from': data['email'],
'to': data['to'],
'text': data["message"],
})
user.current_balance = new_current_balance
user.save()
Message.create(user=user, message=data["message"], to=data['to'])
return make_response(jsonify({"message": "messgae has been sent from {} to {}, your current balance is {}".format(data['email'], data['to'], new_current_balance)}), 200)
else:
return make_response(jsonify({"message": "user account not valid, check email and passwword"}), 403)
def message_handler(msg):
logger.debug('Message: %s', msg)
if msg['text'] in bad_words or len(msg['text']) < 2 or len(
msg['text']) > 229:
flash('Message contains bad words or message length is inappropriate')
return redirect(url_for('index'))
else:
Message.create(text=msg['text'],
sender=msg['sender'],
category=msg['category'])
send(msg, broadcast=True)
def seed_db():
""" Seed the database """
from models import Post, Message, FileWrapper
user_seed = [
('root', 'root', '*****@*****.**', True, 'OLUZCVLVD2BKCBMP'),
('admin', 'admin', '*****@*****.**', True, '2NSG4USG6OYEQZP3'),
('Max', 'max_password_123', '*****@*****.**', False,
'A3VDR4PZZYZDCAU7'),
('Alex', 'alex_password_123', '*****@*****.**', False,
'PMRJMUAUIPOGKUSV'),
('Robert', 'robert_password_123', '*****@*****.**', False,
'UYNKXN3BOBV2H2KG'),
('Anna', 'anna_password_123', '*****@*****.**', False,
'4XPLBU5GTDPT72H2'),
]
nr_public_posts = 100
nr_private_posts = 100
users = []
print('Creating users')
# Create users
for u in user_seed:
user = create_user(*u)
if user:
users.append(user)
print_dot()
else:
print('Failed to create user')
print('\nCreating public posts')
# Create public posts for each user
for i in range(nr_public_posts):
user = random.choice(users)
sentence, filename = create_entry([user.id], False)
Post.create(user.id, sentence, filename)
print_dot()
print('\nCreating private messages')
for i in range(nr_private_posts):
random.shuffle(users)
author = users[0]
recipient = users[1]
sentence, filename = create_entry([author.id, recipient.id], True)
Message.create(author.id, recipient.id, sentence, filename)
print_dot()
print("")
def lambda_handler(event, context):
request = event['body']
uuid = str(uuid4())
payload = {
'name': ' '.join([request['first_name'], request['last_name']]),
'email_address': request['email_address'],
'message': request['message'],
'uuid': uuid,
'phone_number': request['phone_number'],
}
my_message = Message.create(payload)
response = {
'isBase64Encoded': False,
'statusCode': 201,
'body': {
'id': uuid
},
'headers': {
'location':
'/'.join(['http://example.com',
my_message.serialize()['uuid']])
},
}
print(json.dumps(response)) # log this
return response # respond to the gateway
async def log_message_add(self, message):
if message.author.bot or message.guild is None:
return
try:
# Ensure user exists in the guild.
User.first_or_create(id=message.author.id,
guild_id=message.guild.id)
# Add the message to the database.
Message.create(id=message.id, author_id=message.author.id,
content=message.content)
except QueryException:
ut.log(f"Failed to add message '{message.content}' for user "
f"{message.author.id} in guild {message.guild.id}",
ut.LogLevel.WARNING)
def message_add(from_username, to_username):
""" Create a message.
Takes in { message: { body, from_user, to_user }}
Returns => {
message: {
body,
from_user,
to_user,
sent_at,
read_at,
}
}
TODO: Auth required: to_user or from_user equals logged in user
"""
# from_username = User.query.get_or_404(from_username)
# to_username = User.query.get_or_404(to_username)
message_data = request.json.get("message")
form = MessageCreateForm(data=message_data)
if form.validate():
message = Message.create(form)
db.session.commit()
return (jsonify(message=message.serialize()), 200)
else:
errors = []
for field in form:
for error in field.errors:
errors.append(error)
return (jsonify(errors=errors), 400)
def on_message(self, model):
user = self.environ['user']
if user is None:
# 手动从store中取出user
session_id = self.environ['session_id']
_data = session.store[session_id]
user = _data['user']
model.update({
"user_id": user.id,
"created_time": datetime.now(),
})
m_id = Message.create(**model)
raw_content = model.get('content')
model.update({
"content": markdown.markdown(raw_content),
"raw_content": raw_content,
"user_name": user.username,
'id': m_id,
'created_time': display_time(model['created_time']),
'is_mine': True,
})
# 发送回客户端
self.emit('message', model)
# 发送给其他人
model['is_mine'] = False
self.emit_to_room(
self.socket.session['room'],
'message',
model,
)
def on_message(self, model):
user = self.environ['user']
if user is None:
# 手动从store中取出user
session_id = self.environ['session_id']
_data = session.store[session_id]
user = _data['user']
model.update({
"user_id": user.id,
"created_time": datetime.now(),
})
m_id = Message.create(**model)
model.update({
"user_name": user.username,
'id': m_id,
'created_time': str(model['created_time']),
'is_mine': True,
})
# 发送回客户端
self.emit('message', model)
# 发送给其他人
model['is_mine'] = False
self.emit_to_room(
self.socket.session['room'],
'message',
model,
)
def create_message(message):
"""
Creates a new message and sent it to all connected clients
"""
msg = Message.create(message=message)
for c in clients:
c.write_message(msg.to_json)
def on_message(self, model):
user = self.environ['user']
if user is None:
# 手动从store中取出user
session_id = self.environ['session_id']
_data = session.store[session_id]
user = _data['user']
model.update({
"user_id": user.id,
"created_time": datetime.now(),
})
m_id = Message.create(**model)
model.update({
"user_name": user.username,
'id': m_id,
'created_time': str(model['created_time']),
'is_mine': True,
})
# 发送回客户端
self.emit('message', model)
# 发送给其他人
model['is_mine'] = False
self.emit_to_room(
self.socket.session['room'],
'message',
model,
)
def create():
user = auth.get_logged_in_user()
if request.method == "POST" and request.form["content"]:
message = Message.create(user=user, content=request.form["content"])
flash("Your message has been created")
return redirect(url_for("homepage"))
return render_template("create.html")
def composeNewMail(message):
result = outBoundMail(message)
user = message.get('sender')
notify = message.get('notification_email')
msg = Message.create(message)
user.notify_mail = notify
user.put()
print user.notify_mail
return result
def callback(bot: telegram.Bot, update: telegram.Update):
if settings.DEBUG:
logger.debug('update: %s', update)
reply_markup = get_reply_markup()
text = format_text(update.message.from_user, update.message.text)
kwargs = dict(chat_id=update.message.chat_id,
reply_markup=reply_markup,
text=text)
bot_msg = bot.send_message(**kwargs)
try:
with db:
Message.create(message_tg_id=bot_msg.message_id,
chat_tg_id=update.message.chat_id,
user_tg_id=update.message.from_user.id)
bot.delete_message(update.message.chat_id, update.message.message_id)
except Exception:
logger.exception('exception while adding text message %s', update)
def testCron(self):
n3 = uuid.uuid4().hex
u3 = User.create(n3, fakePublicKey())
u3.timestamp = datetime.now() - timedelta(LIMITS['DAYS']+1)
u3.put() # Pretend u3 is old.
u4 = User.create(uuid.uuid4().hex, fakePublicKey())
m34 = Message.create(u3, u4, 'one')
m43 = Message.create(u4, u3, 'two')
self.assertEqual(1, len([m for m in u4.inbox]))
self.assertEqual(1, len([m for m in u4.outbox]))
status, result = views.cron() # Should delete u4 and both messages.
self.assertEqual(200, status)
nu, nm = json.loads(result)
self.assertEqual(1, nu)
self.assertEqual(2, nm)
self.assertEqual(0, len([m for m in u4.inbox]))
self.assertEqual(0, len([m for m in u4.outbox]))
self.assertEqual(None, User.get(n3))
self.assertEqual(u4.public_key, User.get(u4.name).public_key)
u4.delete()
def create():
user = auth.get_logged_in_user()
if request.method == 'POST' and request.form['content']:
message = Message.create(
user=user,
content=request.form['content'],
)
flash('Your message has been created')
return redirect(url_for('user_detail', username=user.username))
return render_template('create.html')
def create():
user = auth.get_logged_in_user()
if request.method == 'POST' and request.form['content']:
message = Message.create(
user=user,
content=request.form['content'],
)
flash('Your post has been created')
return redirect(url_for('user_detail', username=user.username))
return render_template('create.html')
def send(user_id):
u = get_object_or_404(User, user_id)
text = request.form['text']
if text is None:
abort(400)
m = Message.create(text=text, date=datetime.now(), read=False, receiver=u)
return jsonify(model_to_dict(m, recurse=False)), 201, {
'location': url_for('get_message', message_id=m.id)
}
def new_message():
"""
Post a new message.
This endpoint is requires a valid user token.
"""
msg = Message.create(request.get_json() or {})
db.session.add(msg)
db.session.commit()
r = jsonify(msg.to_dict())
r.status_code = 201
r.headers['Location'] = url_for('get_message', id=msg.id)
return r
def create_messages(ids, filename):
c = vk_api.get_users_messages(ids, VK_USER_TOKEN)
with open('create_messages.json', 'w', encoding='utf8') as f:
json.dump(c, f)
with open(filename, 'w', encoding='utf8') as f:
for i in c:
author_id = User.get(User.vk_id == i['id'])
if isinstance(i['messages'], dict):
for b in i['messages']['items']:
try:
Message.create(link=vk_link_pattern.format(
user_id=i['id'], message_id=b['id']),
message=' '.join(b['text'].split('\n')),
author=author_id,
date=date.fromtimestamp(b['date']))
f.write(' '.join(b['text'].split('\n')) + '\n')
except Exception as exc:
print(exc)
continue
def callback_handler(update: Update, ctx: CallbackContext):
query = update.callback_query
callback_data = query.data
tg_id = query.message.chat.id
message = Message.create(message_id=query.message.message_id,
text=query.message.text)
message.save()
print(Message.get(message_id=message.message_id))
if callback_data == 'publish':
print('Deeplink')
def _process_slack_raw_message(self, slack_raw_message):
'''
_process_slack_raw_message(slack_raw_message)
'''
user, message, new = None, None, False
try:
try:
user = User.get(
User.slack_id == slack_raw_message['user']
)
except User.DoesNotExist:
if len(slack_raw_message['user']) == 0:
raise Exception("Raw slack message user field empty.")
self.slack.member_id_name_maps()
slack_name = self.slack.member_id_to_name_map.get(
slack_raw_message['user'],
''
) or ''
if len(slack_name) == 0:
raise Exception('Could not find slack name.')
user = User(
slack_id=str(slack_raw_message['user']),
slack_name=slack_name
)
user.save()
try:
message = Message.get(
Message.slack_timestamp == slack_raw_message['timestamp'],
Message.user == user,
Message.channel == self.channel
)
new = False
except Message.DoesNotExist:
message = Message.create(
text=slack_raw_message['text'],
slack_timestamp=slack_raw_message['timestamp'],
channel=self.channel,
user=user
)
new = True
except Exception as error:
self.error(error)
return user, message, new
def testGetAllMessagesLimit(self):
n3, k3 = uuid.uuid4().hex, fakePublicKey()
u3 = User.create(n3, k3)
ms = [Message.create(u3, u3, uuid.uuid4().hex)
for i in range(LIMITS['MESSAGES']+1)]
status, result = views.getAllMessages()
self.assertEqual(200, status)
ms1 = json.loads(result)
self.assertEqual(LIMITS['MESSAGES'], len(ms1))
status, result = views.getMyMessages(n3)
self.assertEqual(200, status)
ms2 = json.loads(result)
self.assertEqual(LIMITS['MESSAGES'], len(ms2))
# Clean up
for m in ms:
m.delete()
u3.delete()
def messages():
# Post: params[recipient, content, file]
if request.method == 'GET':
messages = Message.get_messages_for_user_id(g.user.id)
return TemplateManager.get_messages_template(messages)
else:
message_content = request.form['message_content'].strip()
recipient_name = request.form['message_recipient'].strip()
messages = Message.get_messages_for_user_id(g.user.id)
recipient = User.get_user_by_name(recipient_name)
if not recipient:
return TemplateManager.get_messages_template(
messages, ["Unknown recipient"])
attachment = request.files.get('attachment')
if attachment:
errors = FileWrapper.is_valid_file(attachment)
if len(errors):
return TemplateManager.get_messages_template(messages, errors)
if message_content == "" and (attachment is None or (
attachment is not None and attachment.filename == '')):
return TemplateManager.get_messages_template(
messages, ["Message can't be empty"])
filename = None
if attachment:
wrapper = FileWrapper.create(
attachment, [g.user.id, recipient.id], True)
if not wrapper:
return TemplateManager.get_index_template(
messages, ['Could not upload file'])
filename = wrapper.get_filename()
message = Message.create(
g.user.id, recipient.id, message_content, filename)
if not message:
return TemplateManager.get_messages_template(
messages, ["Could not create message"])
messages = Message.get_messages_for_user_id(g.user.id)
return TemplateManager.get_messages_template(messages), httplib.CREATED
def composeNewMail(message):
user = message.get("sender")
notify = message.get("notification_email")
result = False
try:
result = outBoundMail(message)
except:
return False
if result != False:
try:
msg = Message.create(message)
user.notify_mail = notify
user.put()
# print user.notify_mail
return result
except:
return False
else:
return False
async def on_message(self, message):
member, _ = Member.get_or_create(
discordID=message.author.id, defaults={"name": message.author.display_name}
)
name = (
message.channel.name
if isinstance(message.channel, discord.TextChannel)
else "DM"
)
channel, _ = Channel.get_or_create(
discordID=message.channel.id, defaults={"name": name}
)
message = Message.create(
discordID=message.id,
member=member,
channel=channel,
message=message.content,
# embed = str(message.embeds),
)
def _process_slack_raw_message(self, slack_raw_message):
user, message, new = None, None, False
SlackChannelSubscriber.lock.acquire()
try:
user = User.get(User.slack_id == slack_raw_message['user'])
try:
message = Message.get(
Message.slack_timestamp == slack_raw_message['timestamp'],
Message.user == user, Message.channel == self.channel)
new = False
except Message.DoesNotExist:
message = Message.create(
text=slack_raw_message['text'],
slack_timestamp=slack_raw_message['timestamp'],
channel=self.channel,
user=user)
new = True
except Exception as e:
self.error(e)
finally:
SlackChannelSubscriber.lock.release()
return user, message, new
def sendReply(user, msg_id, msg, msg_raw, subject, recipient_name, notify):
message = Message.get_by_id(int(msg_id))
new_message = {}
new_message['sender'] = user
new_message['subject'] = subject
new_message['sender_name'] = user.first_name + " " + user.last_name
new_message['sender_email'] = user.alias
new_message['receiver'] = message.sender
new_message['receiver_name'] = recipient_name
new_message['receiver_email'] = message.sender.email
new_message['content'] = msg_raw
new_message['type'] = 'reply_to'
new_message['category'] = message.sender.user_profile
new_message['date'] = strftime("%a, %d %b %Y %X +0000", gmtime())
result = outBoundMail(new_message)
msg = Message.create(new_message)
new_notify = sendCopy(new_message, notify)
user.notify_mail = notify
user.put()
print new_notify
print result
return msg
def POST(self):
data = web.data()
data = json.loads(data)
if not (session.user and session.user.id):
return bad_request("请先登录！")
message_data = {
"content": data.get("content"),
"topic_id": data.get("topic_id"),
"user_id": session.user.id,
"created_time": datetime.now(),
}
m_id = Message.create(**message_data)
result = {
"id": m_id,
"content": message_data.get("content"),
"topic_id": message_data.get("topic_id"),
"user_id": session.user.id,
"user_name": session.user.username,
"created_time": str(message_data.get("created_time")),
"is_mine": True,
}
return json.dumps(result)
def POST(self):
data = web.data()
data = json.loads(data)
if not session.user or session.user.id is None:
return bad_request("请先登录！")
message_data = {
"content": data.get("content"),
"topic_id": data.get("topic_id"),
"user_id": session.user.id,
"created_time": datetime.now(),
}
m_id = Message.create(**message_data)
result = {
"id": m_id,
"content": message_data.get("content"),
"topic_id": message_data.get("topic_id"),
"user_id": session.user.id,
"user_name": session.user.username,
"created_time": display_time(message_data.get("created_time")),
"is_mine": True,
}
return json.dumps(result)
def message_flow(update: Update, ctx: CallbackContext):
"""A handler for all messages sent by a user"""
text = update.message.text
tg_id = update.message.chat.id
user = User.get(tg_id=tg_id)
if text == NEW_MESSAGE:
ctx.bot.send_message(
chat_id=tg_id,
text='Ok. Send me a message that you want to be published\n\n'
'For text formatting you can use html tags\n\n'
'↘️',
reply_markup=ReplyKeyboardRemove()
)
user.mode = modes['creating_message']
user.save()
return
if text == EDIT_MESSAGE:
ctx.bot.send_message(
chat_id=tg_id,
text='⚙️ <b>Text editing</b>\n'
'Send me the changed text.\n\n'
'You can use html for text fromatting\n\n'
'↘️'
)
user.mode = modes['editing_message']
user.save()
return
if user.mode == modes['creating_message'] or user.mode == modes['editing_message']:
global old_message, old_message_2
# if user.mode == modes['editing_message']:
# message_id_to_delete =
# publish_id =
out_msg = make_msg(text)
r = ctx.bot.send_message(chat_id=tg_id, text=out_msg, reply_markup=reactions, parse_mode='HTML', disable_web_page_preview=True)
reply_to_message_id = update.message.message_id
# text = 'There is no old Message'
if old_message is not None:
ctx.bot.delete_message(chat_id=tg_id, message_id=old_message.message_id)
if old_message_2 is not None:
ctx.bot.delete_message(chat_id=tg_id, message_id=old_message_2.message_id)
# delete all previous records in the message database
message_id = r.message_id
# records = Message.select().where(type(message_id) == int)
# Message.delete().where(records).execute()
interface_msg = '⬆️ <b>Will be looking like that.\n\nIf you want to change the message just send me another one</b>'
tg_message = ctx.bot.send_message(chat_id=tg_id, text=interface_msg, reply_markup=send_message_markup, parse_mode='HTML', reply_to_message_id=reply_to_message_id)
old_message = tg_message
old_message_2 = r
publish_id = tg_message.message_id
# db
message = Message.create(message_id=update.message.message_id, text=text, out_msg=out_msg)
user.message = message.text
user.message_id = message_id
user.publish_id = publish_id
user.mode = modes['editing_message'] # can cause an error
user.save()
return
def message(self, **kwargs):
chat = kwargs.pop("chat", None) or self.chat()
return Message.create(chat=chat, **kwargs)
