def post(self):
name = self.request.get("name")
message = self.request.get("message")
time = datetime.now().strftime("%d.%m.%Y ob %H:%M")
save_message = Chat(name=name, message=message, time=time)
save_message.put()
return self.redirect_to("main-page")
def process_message(update):
chat_id = update['message']['chat']['id']
data = {}
data['chat_id'] = chat_id
print(update['message']['text'])
if (update['message']['text'].startswith('/token')):
with app.app_context():
chat = Chat.query.filter_by(chat_id=chat_id, revoked=False).first()
if (chat == None):
new_uuid = str(uuid.uuid1()).replace('-', '')
# TO-DO: ADD CHECK TO SEE IF UUID ALREADY EXISTS
new_chat = Chat(chat_id=str(chat_id), token=new_uuid)
db.session.add(new_chat)
db.session.commit()
data['text'] = 'Here is your token: {}'.format(new_uuid)
else:
data['text'] = 'Looks like you already have a token for this chat.\n' \
'Here it is: {}'.format(chat.token)
elif (update['message']['text'].startswith('/revoke')):
with app.app_context():
chat = Chat.query.filter_by(chat_id=chat_id, revoked=False).first()
if (chat == None):
data['text'] = 'You have no active token.'
else:
chat.revoked = True
db.session.commit()
data[
'text'] = 'Token revoked. Please use /token to generate a new one.'
else:
data[
'text'] = 'Hi, please use the available commands:\n/token to generate a new token or\n/revoke to revoke a token.'
r = requests.post(get_url('sendMessage'), data=data)
def newroom():
if not g.user:
abort(404)
elif request.method == "POST":
POST_ROOM = remove_tags(str(request.form['room']))
POST_CHAT = remove_tags(str(request.form['msg']))
if POST_CHAT != None:
newRoom = Room(POST_ROOM, g.user.id, None, None)
eprint("newRoom: " + str(newRoom))
db.session.add(newRoom)
try:
db.session.commit()
newChat = Chat(newRoom.id, g.user.id, None, POST_CHAT)
eprint("newChat: " + str(newChat))
db.session.add(newChat)
try:
db.session.commit()
flash ("Created room: " + str(newRoom.roomname))
return redirect(url_for("joinroom", rid=newRoom.id))
except Exception as e:
db.session.rollback()
eprint(str(e))
flash("Error adding message to new room")
return redirect(url_for("newroom"))
except Exception as e:
flash("Room creation failed")
else:
flash("Must enter initial message")
return Response(render_template('/rooms/newRoom.html'), mimetype='text/html')
def form_valid(self, form):
if self.can_not_send_mess:
self.set_message(
u'Вы не можете добавлять коментарии не ко своим вопросам',
True)
return self.form_invalid(form)
body = form.cleaned_data['body']
file = form.cleaned_data['file']
new_msg = Chat(question=self.question,
admin_name=self.user,
body=body,
date=now())
new_msg.save()
if file:
new_file = Files(content_object=new_msg,
file=file,
name=file.name,
size=file.size,
date=now())
new_file.save()
answers_count = Chat.objects.filter(question=self.question).count()
self.question.answers = answers_count
self.question.save()
self.set_message(u'Ответ успешно добавлен.')
return super(QuesChatForm, self).form_valid(form)
def add_chat(user_id, msg_recieved, msg_replied, recieved_time, replied_time):
chat = Chat(user_id=user_id,
message_recieved=msg_recieved,
message_reply=msg_replied,
recieved_time=recieved_time,
reply_time=replied_time)
db.session.add(chat)
db.session.commit()
def get_chat(update):
chat_id = update.message.chat.id
chat = session.query(Chat).get(chat_id)
if chat is None:
chat = Chat(id=chat_id)
session.add(chat)
session.commit()
return chat
def register_chat(self, msg):
chat_id = msg['chat'].get('id')
chat_type = msg['chat'].get('type')
title = msg['chat'].get('title')
chat = Chat(chat_id=chat_id, chat_type=chat_type, title=title)
self.session.add(chat)
self.session.commit()
return chat
def _add_chat(self, chat_id):
try:
chat = Chat(chat_id=chat_id, state='ready')
db.session.add(chat)
db.session.commit()
result = 'Добро пожаловать!'
except:
result = 'Ошибка регистрации'
return result
def start(bot, update):
chat_id = update.message.chat.id
chat = session.query(Chat).get(chat_id)
if chat is not None:
return help_me(bot, update)
chat = Chat(id=chat_id)
session.add(chat)
session.commit()
update.message.reply_text("Hola!, ¿necesitas /ayuda?\n")
def add_chat(request):
text = str(request.GET.get("text", ""))
name = str(request.GET.get("name", ""))
if text == "" or name == "":
return JsonResponse({'status': 'ERROR'})
chat = Chat()
chat.name = name
chat.chat = text
chat.save()
return JsonResponse({'status': 'OK'})
def post_chat(request):
if request.method == 'POST':
response = request.META.get('HTTP_REFERER', '/')
chat = Chat()
chat.content = request.POST.get('chat_content')
chat.sender = request.user
chat.save()
return HttpResponseRedirect(response)
else:
raise Http404
def post(self):
user = users.get_current_user()
name = user.nickname()
message = self.request.get("message")
# datum = self.request.get("nastanek") # datume generira avtomaticno
new_message = Chat(name=name, message=message)
new_message.put()
seznam = Chat.query().fetch()
#seznam = sorted(seznam)
params = {"seznam": seznam, "user_nick": name}
return self.redirect_to("main", params=params)
def add_new_chat(message):
Chat(id=str(message.chat.id),
type=message.chat.type,
title=message.chat.title,
username=message.chat.username,
first_name=message.chat.first_name,
last_name=message.chat.last_name,
photo=message.chat.photo,
description=message.chat.description,
invite_link=message.chat.invite_link,
pinned_message=message.chat.pinned_message)
def new_message(message):
# Emitimos el mensaje con el alias y el mensaje del usuario
emit('new_message', {
'username': message['username'],
'text': message['text']
},
broadcast=True)
# Salvamos el mensaje en la base de datos
my_new_chat = Chat(username=message['username'], text=message['text'])
db.session.add(my_new_chat)
db.session.commit()
def save_chat(chat_name: str):
"""
Salva o nome de todos os chats
:param str_chat: Lista contendo o nome de todos os chats.
:type str_chat: list
"""
db_url = config('DATABASE_URL')
port = config('DATABASE_PORT', cast=int)
c = Chat(db_url, port, chat_name)
chat_obj = c.find_chat()
if chat_obj is False:
c.update_chat()
def db_update_chat(chat_id, step, place_id=None):
chat = db_get_chat(chat_id)
if chat:
chat.step = step
if place_id:
chat.place_id = place_id
else:
chat = Chat(id=chat_id, step=step)
session.add(chat)
session.commit()
return chat
def insert_chat_id(chat_id):
""" Add chat_id to the database of chats. """
if not is_returning_chat(chat_id):
chat = Chat(chat_id=chat_id)
db_session.add(chat)
db_session.commit()
logger.info(
f'Inserted new chat_id: {chat_id}. Total Chats: {get_chats()}')
return True
return False
def create():
"""
Create a new chat"""
form = NewChatForm()
if request.method == "POST":
if form.validate_on_submit():
new_chat = Chat(name=form.name.data)
db.session.add(new_chat)
current_user.chats.append(new_chat)
db.session.commit()
return redirect(url_for('main'))
return render_template('create.html', form=form)
def add_message():
body = request.get_json()
db.session.add(
Chat(fromId=body["fromId"],
fromName=body["fromName"],
fromEmail=body["fromEmail"],
toId=body["toId"],
toName=body["toName"],
toEmail=body["toEmail"],
message=body["message"],
dateSent=body["dateSent"]))
def query_all_chats(db_path: str, contacts: Dict[str,
Optional[str]]) -> List[Chat]:
chats = []
con = sqlite3.connect(db_path)
cur = con.cursor()
query = "SELECT raw_string_jid as key_remote_jid, subject, sort_timestamp FROM chat_view WHERE sort_timestamp IS NOT NULL ORDER BY sort_timestamp DESC"
for key_remote_jid, subject, sort_timestamp in cur.execute(query):
chats.append(
Chat(key_remote_jid, subject, sort_timestamp,
contacts.get(key_remote_jid, None),
query_messages(con, key_remote_jid, contacts)))
con.close()
return chats
def add():
eprint(str(request.json))
message = request.json["msg"]
message = remove_tags(message)
newChat = Chat(g.user.currentroom, g.user.id, None, message)
db.session.add(newChat)
try:
db.session.commit()
flash ("Message received")
return ('', 204)
except Exception as e:
db.session.rollback()
flash("Error receiving message")
return ('', 510)
def select_chat(connection: DictConnection, chat_id: int) -> Optional[Chat]:
logging.info(f"DB: selecting chat: chat_id=[{chat_id}]")
with get_cursor(connection) as cursor:
cursor.execute(
"select chat_id, chat_title, chat_username, is_anarchy_enabled"
" from chat"
" where chat_id = %(chat_id)s", {"chat_id": chat_id})
row = cursor.fetchone()
if not row:
return None
return Chat(chat_id=row["chat_id"],
chat_title=row["chat_title"],
chat_username=row["chat_username"],
is_anarchy_enabled=row["is_anarchy_enabled"])
def chat(self, *args, **kwargs):
errors = {}
if 'message' not in kwargs or len(kwargs['message']) is 0:
errors['message'] = 'Enter a chat message'
if errors:
self.send_error(errors)
else:
self.send({'status': 'ok'})
chat = Chat()
chat.text = kwargs['message']
chat.user_receive_id = kwargs['user']
chat.user_sent = User.objects.get(id=kwargs['user_sent'])
chat.save()
self.publish(self.get_subscription_channels(), kwargs)
def persist_chat(chat: Dict):
migrate_from = 'migrate_from_chat_id'
migrate_to = 'migrate_to_chat_id'
chat_has_migrated = (migrate_to in chat and migrate_from in chat)
original_id = chat[migrate_from] if chat_has_migrated else chat['id']
original_registry = Chat.query.filter(Chat.chat_id == original_id).first()
title = None if 'title' not in chat else chat['title']
if original_registry is None:
Chat(title=title, chat_id=chat['id']).save()
else:
if chat_has_migrated:
original_registry.update(chat_id=chat[migrate_to])
if original_registry.title != title:
original_registry.update(title=title)
def say(request):
req = simplejson.loads(request.raw_post_data)
username = req['username']
content = req['content']
if not content:
return HttpResponse(simplejson.dumps({'success': False}),
mimetype='application/json')
chat = Chat()
chat.content = content
chat.username = username
chat.save()
return HttpResponse(simplejson.dumps({'success': True}),
mimetype='application/json')
def new_message(message):
# Send message to alls users
emit('channel-' + str(message['channel']), {
'username': message['username'],
'text': message['text']
},
broadcast=True)
# Save message
my_new_chat = Chat(username=message['username'],
text=message['text'],
channel=message['channel'])
db.session.add(my_new_chat)
try:
db.session.commit()
except:
db.session.rollback()
async def constructMetadata(self, message):
try:
session = Session()
session.expire_on_commit = False
if (message.guild):
current_server = Server(id=message.guild.id,
service_id=self.service.id,
server_name=message.guild.name)
else:
current_server = None
current_user = User(id=message.author.id,
service_id=self.service.id,
username=message.author.display_name)
if (message.channel.name):
current_channel = Chat(id=message.channel.id,
server_id=current_server.id,
chat_name=message.channel.name,
nsfw=message.channel.is_nsfw())
else:
current_channel = get_or_create(session,
Chat,
id=message.channel.id,
server_id=current_server.id,
chat_name=message.channel.id)
except Exception as e:
logger.error("Couldn't get data from message! " + str(e))
return None
# Metadata for use by commands and reactions
metadata = {
"service": self.service,
"user": current_user,
"server": current_server,
"chat": current_channel,
"message": message,
"client": self
}
return metadata
def add_list_chats(chats):
for chat in tqdm(chats):
account = random.choice(Account.query.filter_by(valid=True).all())
chat_parser = ChatParserMethods(
StringSession(account.session),
api_hash='5c10a75e8f9a21326fa191dc8dd4d916',
api_id=933676)
chat_parser.connect()
usernames_obj = [
chat.username
for chat in db.session.query(UserNames.chat).filter_by(
username=chat).all()
]
if chat in usernames_obj:
continue
try:
chat_entity = chat_parser.get_entity(chat)
if type(chat_entity) == User:
continue
chat_obj = Chat.query.get(chat_entity.id)
if not chat_obj:
chat_username_obj = UserNames.query.filter_by(
username=chat_entity.username).first()
if not chat_username_obj:
chat_username_obj = UserNames(
username=chat_entity.username)
chat_obj = Chat(id=chat_entity.id,
user_names=[chat_username_obj],
title=chat_entity.title)
db.session.add(chat_obj)
db.session.commit()
except UsernameInvalidError:
print(f"UsernameInvalidError: {chat}")
continue
except FloodWaitError:
print(f"FloodWaitError:")
chat_parser.valid = False
db.session.commit()
except Exception as e:
print(f"Exception: {e}")
continue
def profile(username):
all_chats = Chat.query.order_by(Chat.chat_id).all()
if request.method == "GET":
return render_template("profile.html",
username=g.user.username,
chats=all_chats)
elif request.method == "POST":
if not request.form['chatName']:
flash("You must enter a chat name to create a new chat!")
elif get_chat_id(request.form['chatName']) is not None:
flash("This chat name has already been used, please try another!")
else:
db.session.add(Chat(g.user.id, request.form['chatName']))
db.session.commit()
flash(
"You have created a new chatroom, you can find this in the list of chatrooms to join"
)
all_chats = Chat.query.order_by(Chat.chat_id).all()
return render_template("profile.html",
username=g.user.username,
chats=all_chats)
def post(self, group_key):
participant_key = ChatTrait.get_participant_key(self)
msg_type = self.get_argument("type", "")
message = self.get_argument("message", "")
reference = self.get_argument("reference", "")
chat = Chat(type=msg_type, message=message)
#set reference if exist
if reference:
reference = Chat.get(reference)
if reference is not None:
chat.reference = reference.key
chat.store(group_key, participant_key)
# send same group members (include myself)
ChatSocketHandler.broadcast(group_key, chat)
return self.write({})
