def send_message(msg):
from app import db,models
try:
if session['role']!='judge':
tempM = models.Message(session['role'],msg['data'],'judge')
else:
tempM = models.Message(session['role'],msg['data'],msg['toRole'])
except KeyError:
return redirect(url_for('login'))
db.session.add(tempM)
db.session.commit()
emit('new_message',{'data':msg['data'],'role':session['role'],'time':str(datetime.now())[10:19],'toRole':msg['toRole']},callback=ack,broadcast=True)
def request_message(data):
# TODO(clogic): event trigger해서 bot도 메시지 보내도록 해야 함
context: ApiContext = create_context()
user_ids = [u.id for u in context.user.chatroom.users]
chatroom = context.user.chatroom
chatroom_users = chatroom.users
message = data.get('message', '')
send_message = context.user.send_message(message)
send(send_message.to_json(), broadcast=True, room=chatroom.url)
try:
message = context.session.query(models.Message).all()[-1].created_at
last_question = (context.session.query(
models.Message).filter(models.Message.user == None).all()[-1].text)
except Exception:
context.session.commit()
return
res = (context.session.query(models.Question).filter(
models.Question.message == last_question).filter(
models.Question.user_id.in_(user_ids)).all())
# if datetime.now() > message + timedelta(hours=3) and not res: # REAL CODE
# if True: # TEST
if not res: # TEST
questions = []
for u in context.user.chatroom.users:
'''if u.id == context.user.id: # REAL_CODE
continue'''
questions += u.questions
selected = random.choice(questions)
question = models.Message(chatroom=chatroom, text=selected.message)
context.session.add(question)
context.session.flush()
send(question.to_json(), broadcast=True, room=chatroom.url)
else:
q: models.Question = random.choice(res)
m = models.Message(chatroom=chatroom, text=q.answer)
context.session.add(m)
context.session.flush()
send(m.to_json(), broadcast=True, room=chatroom.url)
context.session.commit()
def make_seed_scheme_submission(assignment, submitter, final=False):
with open('app/seed/scheme.py') as sc, \
open('app/seed/scheme_reader.py') as sr, \
open('app/seed/tests.scm') as tests, \
open('app/seed/questions.scm') as quest:
messages = {}
messages['file_contents'] = {
'scheme.py': sc.read(),
'scheme_reader.py': sr.read(),
'tests.scm': tests.read(),
'questsions.scm': quest.read(),
'submit': final
}
messages = [
models.Message(kind=kind, contents=contents)
for kind, contents in messages.items()
]
backup = models.Backup(messages=messages,
assignment=assignment.key,
submitter=submitter.key,
client_time=random_date())
backup.put()
return models.Submission(backup=backup.key)
def get_data():
for c in champions:
try:
path1 = '/home/vanhocvp/Code/AI/NLP/API/Crawl_data/bang_ngoc/' + c + '.png'
socket = open(path1, 'rb')
path2 = '/home/vanhocvp/Code/AI/NLP/API/Crawl_data/up_skill/' + c + '.png'
up_skill = open(path2, 'rb')
except:
print(c)
continue
path1 = '/home/vanhocvp/Code/AI/NLP/API/Crawl_data/bang_ngoc/' + c + '.png'
socket = open(path1, 'rb')
path2 = '/home/vanhocvp/Code/AI/NLP/API/Crawl_data/up_skill/' + c + '.png'
up_skill = open(path2, 'rb')
x = models.Message(hero=c,
build_item=build_item1[c],
support_socket=socket.read(),
counter=counter1[c],
be_countered=be_countered1[c],
skill_up=up_skill.read(),
how_to_play=how_to_play1[c],
combo=combo1[c],
combine_with=combine_with1[c],
how_to_use_skill=how_to_use_skill1[c],
introduce=introduce1[c])
db.session.add(x)
db.session.commit()
def send_message():
request_json = request.get_json()
body = request_json['body']
recipients = request_json['recipients']
if recipients is None or body is None:
abort(400) # missing args
recipients_tuple = tuple(recipients)
message = models.Message(text=body,
author=auth.user,
create_time=datetime.utcnow())
if recipients_tuple in auth.user.conversations:
#conversation between recipients already exists
conversation_id = auth.user.conversations[recipients]
models.send_message(recipients_tuple, conversation_id, message)
else:
models.start_conversation(recipients_tuple, auth.user, message)
#use objectID from map to find conversation ID
#add message to conversation
#else
#create conversation
#add new message to conversation
# insert conversation objectID into conversation map for each user in recipients list, including calling user
return jsonify({"message sent": body})
def make_seed_submission(assignment, submitter, final=False):
with open('app/seed/hog_modified.py') as fp:
messages = {}
messages['file_contents'] = {
'hog.py': fp.read(),
'hogq.scm': 'Blank Stuff',
'submit': final
}
g = models.User(email=["*****@*****.**"], is_admin=True)
g.put()
score = models.Score(score=88, tag='test', grader=g.key)
score.put()
messages = [
models.Message(kind=kind, contents=contents)
for kind, contents in messages.items()
]
score = models.Score(score=10)
score.put()
backup = models.Backup(messages=messages,
assignment=assignment.key,
submitter=submitter.key,
client_time=random_date())
backup.put()
return models.Submission(backup=backup.key, score=[score])
def message(username):
user = models.User.query.filter_by(username=username).first_or_404()
# Get the dialogue between current_user and user if it exists
convo = models.Convo.get_dialogue(user, current_user)
if flask_request.method == "POST":
text = flask_request.form.get("text")
if not text:
return json.dumps({'status': 'error'})
if convo:
if convo.activated:
new_msg = models.Message(text=text, sender=current_user)
convo.messages.append(new_msg)
db.session.commit()
return json.dumps({'status': 'success'})
else:
if convo.messages.has(sender=user):
convo.activated = True
new_msg = models.Message(text=text, sender=current_user)
convo.messages.append(new_msg)
db.session.commit()
return json.dumps({'status': 'success'})
else:
new_msg = models.Message(text=text, sender=current_user)
convo.messages.append(new_msg)
db.session.commit()
return json.dumps({'status': 'success'})
elif user in current_user.allies:
print("allies")
convo = models.Convo(activated=True)
convo.members.append(current_user)
convo.members.append(user)
new_msg = models.Message(text=text, sender=current_user)
convo.messages.append(new_msg)
db.session.commit()
return json.dumps({'status': 'success'})
else:
convo = models.Convo()
convo.members.append(current_user)
convo.members.append(user)
db.session.commit()
return json.dumps({'status': 'success'})
return render_template("comms/messages/message.html", user=user, convo=convo, navbar=True, background=True, size="medium", models=models)
def post(self):
data = message_parser.parse_args()
recipient = models.User.query.filter_by(email=data['recipient']).first()
if not recipient:
abort(400, message="Invalid recipient email")
message = models.Message(title=data['title'],
text=data['text'],
recipient=recipient)
db.session.add(message)
db.session.commit()
def message(data):
from_user = models.User.query.filter_by(username=data['from']).first()
to_user = models.User.query.filter_by(username=data['to']).first()
if from_user.is_matched(to_user, data['match_type']):
m = models.Message(content=data['msg'],from_id=from_user.id,to_id=to_user.id,time_sent=datetime.datetime.now(), match_type=data['match_type'], read= False)
db.session.add(m)
db.session.commit()
emit('message response', {'msg': data['msg'], 'to': data['to'], 'from':data['from'], 'match_type': data['match_type'], 'id':m.id}, room=data['to'])
emit('message response', {'msg': data['msg'], 'to': data['to'], 'from':data['from'], 'match_type': data['match_type'], 'id':m.id}, room=data['from'])
def create_one(**kwargs):
"""Create Message entity from kwargs."""
message = models.Message(**kwargs)
db.session.add(message)
try:
db.session.commit()
except IntegrityError:
db.session.rollback()
raise DuplicateError('Message already exists!')
return message
def message(umi,
subject="Test subject",
msgbody="Test message",
to_originally=None):
return models.Message(
user_message_info=umi,
to_originally=json.dumps(to_originally if to_originally is not None
else ['*****@*****.**']),
subject=subject,
msgbody=msgbody,
email_uid=uuid.uuid4().hex)
def submit():
form = SubmitAnything()
if form.validate_on_submit():
flash("Thanks for saying something!")
m = models.Message(message=form.submission.data)
db.session.add(m)
db.session.commit()
return redirect(url_for('index'))
return render_template('submit.html',
title='Submit your thoughts',
form=form)
def index():
form = SubmitAnything()
messages = models.Message.query.all()
if form.validate_on_submit():
flash("Thanks for saying something!")
m = models.Message(message=form.submission.data)
db.session.add(m)
db.session.commit()
return redirect(url_for('index'))
return render_template('index.html',
title='Home',
messages=messages,
form=form)
def send_to(request):
message = request.POST.get('msg', '')
receiver_id = request.POST.get('receiver', -1)
receiver = models.User.objects.get(id=receiver_id)
if message and receiver:
msg = models.Message()
msg.senderID = request.user
msg.receiverID = receiver
msg.content = message
print(msg)
msg.save()
return HttpResponse(1)
else:
return HttpResponse(0)
def forge(count):
"""
生成测试数据
"""
db.drop_all()
db.create_all()
click.echo('Working...')
for i in range(count):
message = models.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 delete_message(
*,
db: Session = Depends(deps.get_db),
message_id: str,
user: Auth0User = Security(auth.get_user)) -> models.Message:
"""Delete a message."""
message = jsonable_encoder(crud.message.get(db=db, id=message_id))
if not message:
raise HTTPException(status_code=404, detail="Message not found")
if message.sender.user_id != user.id:
raise HTTPException(status_code=403, detail="Not allowed")
crud.message.delete(db=db, id=message_id)
return models.Message(**message)
def test_message_create(session):
text = "test text message"
channel_id = 1
room = "test_room"
creating_user = "******"
receiving_user = "******"
message = models.Message(
text=text,
channel_id=channel_id,
room=room,
creating_user=creating_user,
receiving_user=receiving_user,
)
session.add(message)
session.commit()
assert message
def signup(request):
if request.session.get('is_login', None):
return HttpResponseRedirect('/')
if request.method == 'GET':
return render(request, 'signup.html', {'title': '注册'})
else:
response = {
'message': '',
'success': False,
}
username = request.POST['usr']
password = request.POST['pwd']
email = request.POST['email']
phone = request.POST['phone']
verify = request.POST['verify']
if verify != request.session.get('mail_code', None):
response['message'] = '邮箱验证码错误'
return HttpResponse(json.dumps(response),
content_type='application/json')
try:
models.User.objects.get(username=username)
except ObjectDoesNotExist:
user = models.User(username=username,
password=password,
email=email,
phone=phone)
user.save()
response['success'] = True
request.session['is_login'] = True
request.session['username'] = username
message = models.Message(user=user,
message='欢迎使用在线实验平台，祝你学习进步！',
type='站内公告')
message.save()
else:
response['message'] = '用户名已存在'
return HttpResponse(json.dumps(response),
content_type='application/json')
def contact(request):
if request.method == 'GET':
return render(request, 'contact.html')
if request.method == 'POST':
msg = models.Message()
msg.name = request.POST.get('name')
msg.email = request.POST.get('eml')
msg.summary = request.POST.get('subject')
msg.message = request.POST.get('message')
msg.save()
subject = '系统收到一封建议'
message = ''
sender = settings.EMAIL_FROM
recipient = [msg.email]
html_massage = '<h1>%s，为系统发了一封建议</h1><br/><h2>%s<h2><br/><p>%s</p><br>From: $email%s' % (
msg.name, msg.summary, msg.message, msg.email)
send_mail(subject,
message,
sender,
recipient,
html_message=html_massage)
return JsonResponse({'res': 1})
def sendmessage():
ret = models.User.query.filter_by(username = session['username']).first()
if request.method == "POST":
susername = session['username']
rusername = request.form['rusername']
content = request.form['content']
potime = time.strftime(ISOTIMEFORMAT, time.localtime())
idweibo = susername + potime + str(len(content))
wtype = "l"
fatherid = "null"
number = 0
url = ret.url
weibo = models.Weibo(url = url , username = susername , potime = potime ,content = content , idweibo = idweibo, wtype = wtype , fatherid = fatherid ,number = number)
db.session.add(weibo)
db.session.commit()
imessage = idweibo+susername
message = models.Message(susername = susername , rusername = rusername , idweibo = idweibo , imessage = imessage)
db.session.add(message)
db.session.commit()
return render_template("sendmessage.html",ret=ret,nickname=ret.nickname)
return render_template("sendmessage.html",ret=ret,nickname = ret.nickname)
def _insert_message(session,
text="test",
date=datetime.now(),
creating_user="******",
receiving_user="******",
room="room"):
"""
Util function to build a message inside the DB any field is overridable
:param session: required
:param text: str
:param date: datetime
:param creating_user: str
:param receiving_user: str
:param room: str
:return:
"""
message = models.Message(text=text,
channel_id=1,
room=room,
creating_user=creating_user,
receiving_user=receiving_user,
created=date)
session.add(message)
session.commit()
async def send_message(
chat_id: int,
message: Message,
pool: Pool = Depends(get_pool),
current_user: UserResponse = Depends(get_current_verified_user),
db: Session = Depends(get_db),
):
"""Send a message to a chat."""
chat = crud.get_chat(db, current_user.user_id, chat_id)
if not chat:
raise HTTPException(
status_code=status.HTTP_404_NOT_FOUND,
detail=f"The chat with id {chat_id} does not exist.",
)
connector_id = chat.contacts[0].contact.connector_id
connector = crud.get_connector(db, current_user.user_id, connector_id)
if connector.connector_type == "DEMO":
new_message = models.Message(
chat_id=chat_id,
contact_id=connector.connector_user_id,
message=json.dumps(message.message.__dict__),
sent_datetime=datetime.now(),
)
db.add(new_message) # add is ok here
db.commit()
else:
sent = await pool.get(
f"{connector.connector_type}/{connector.connector_id}/{str(uuid.uuid4())}/send_message",
{
"chat_id": chat.internal_id,
"message": message.message.__dict__
},
)
# This should never be null
contact = db.query(models.Contact).filter(
models.Contact.connector_id == connector_id,
models.Contact.is_self).first()
new_message = models.Message(
message_id=crud.get_message_id(connector.connector_id,
sent.get("message_id"), chat_id),
internal_id=sent.get("message_id"),
chat_id=chat_id,
contact_id=contact.contact_id,
message=json.dumps(message.message.__dict__),
sent_datetime=datetime.now(),
)
try:
db.merge(new_message)
db.commit()
except sqlalchemy.exc.IntegrityError:
# happens when the service sends the message already back to the server via push api
pass
return MessageResponse(
message_id=new_message.message_id,
contact_id=new_message.contact_id,
sent_datetime=new_message.sent_datetime,
message=message.message.__dict__,
)
#!/usr/bin/env python
# -*- coding: utf8 -*-
# This is a test fill in script. It is intended to run once, but if you will run it again it will fail to add records to databese because of unique field requeremnt
from app import db, models
message = u'Воруют, воруют, воруют'
m = models.Message(title=u'Сообщение о воровстве',
message=message,
contacts=u'1234567')
db.session.add(m)
db.session.commit()
message = u'Везде бардак, директор бардак, бухгалтер бардак, всё бардак'
m = models.Message(title=u'Сообщение о бардаке',
message=message,
contacts=u'*****@*****.**')
db.session.add(m)
db.session.commit()
message = u'Они делали это, фотки в файле'
m = models.Message(title=u'Непристойное поведение',
message=message,
contacts=u'*****@*****.**',
filename='file.zip')
db.session.add(m)
db.session.commit()
message = u'субж'
m = models.Message(title=u'Вы все казлы',
#!venv/bin/python
from migrate.versioning import api
from config import SQLALCHEMY_DATABASE_URI
from config import SQLALCHEMY_MIGRATE_REPO
from app import db, models
import os.path
db.create_all()
if not os.path.exists(SQLALCHEMY_MIGRATE_REPO):
api.create(SQLALCHEMY_MIGRATE_REPO, 'database repository')
api.version_control(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO)
u = models.User(username='******', password='******', is_admin=True)
u.set_password('admin')
db.session.add(u)
db.session.commit()
m = models.Message(content="Welcome on the chat!", author=u)
db.session.add(m)
db.session.commit()
else:
api.version_control(SQLALCHEMY_DATABASE_URI, SQLALCHEMY_MIGRATE_REPO,
api.version(SQLALCHEMY_MIGRATE_REPO))
def forward():
Username = session['username']
miss = models.User.query.filter_by(username = Username).first()
idweibo = request.args.get('id')
ret = models.Weibo.query.filter_by(idweibo = idweibo).first()
username = ret.username
potime = time.strftime(ISOTIMEFORMAT, time.localtime())
content = "FW : "+ ret.username + " " + ret.content
idweibo = Username + potime + str(len(content))
wtype = "o"
fatherid = "null"
number = 0
url = miss.url
weibo = models.Weibo(url = url , username = username , potime = potime , content = content , idweibo = idweibo ,wtype = wtype ,fatherid=fatherid , number=number)
db.session.add(weibo)
db.session.commit()
username = session['username']
ret = models.User.query.filter_by(username=Username).first()
if request.method == 'POST':
username = Username
potime = time.strftime(ISOTIMEFORMAT, time.localtime())
content = request.form['content']
idweibo = Username + potime + str(len(content))
wtype = "o"
fatherid = "null"
number = 0
url = ret.url
if content[0] == '@':
res = content[1:]
me = models.User.query.filter_by(username = res).first()
if me != None:
wtype = "a"
#content = "<a href='/homepage?uid=" + me.username + "'>" + content + "</a>"
#content = decodeHtml(content)
imessage = idweibo+me.username
susername = username
rusername = me.username
message = models.Message(imessage=imessage,idweibo=idweibo,susername=susername,url=url,rusername=rusername)
db.session.add(message)
db.session.commit()
weibo = models.Weibo(url = url , username = username , potime = potime , content = content , idweibo = idweibo ,wtype = wtype ,fatherid=fatherid , number=number)
db.session.add(weibo)
db.session.commit()
friend = models.Follow.query.filter_by(username=session['username']).all()
ans = [session['username']]
#ans = ans + ['Admin']
for ele in friend:
tt = models.User.query.filter_by(username=ele.followname).first()
if tt.state == 1:
ans = ans + [ele.followname]
posts = []
for ele in ans:
posts = posts + models.Weibo.query.filter_by(username = ele,wtype="o").all()
posts = posts + models.Weibo.query.filter_by(username = ele,wtype="a").all()
posts = sorted(posts, key = lambda d: d.potime, reverse = True)
follows = len(models.Follow.query.filter_by(followname = Username).all())
topic = len(models.Weibo.query.filter_by(username = Username).all())
following = len(models.Follow.query.filter_by(username = Username).all())
point = follows*3 + topic*2 + following*1
ret.point = point
if ret.point>10000:
ret.lvip = 1
db.session.commit()
return render_template("home.html" , posts=posts,ret=ret,nickname=ret.nickname,topic=topic,follows=follows,following=following)
def setUp(self):
super(FinalSubmissionTest, self).setUp()
self.courses = {
"first":
models.Course(institution="UC Awesome",
display_name="First Course",
instructor=[self.accounts['admin'].key]),
"second":
models.Course(institution="UC Awesome",
display_name="Second Course",
instructor=[self.accounts['admin'].key]),
}
for course in self.courses.values():
course.put()
for student in ["student0", "student1", "student2"]:
models.Participant.add_role(self.accounts[student],
self.courses['first'],
constants.STUDENT_ROLE)
self.assignments = {
"first":
models.Assignment(name="first",
points=3,
creator=self.accounts["admin"].key,
course=self.courses['first'].key,
display_name="first display",
templates="{}",
max_group_size=3,
due_date=NOW + datetime.timedelta(days=1)),
}
for assign in self.assignments.values():
assign.put()
self.assign = self.assignments["first"]
self.backups = {
"first":
models.Backup(
submitter=self.accounts["student0"].key,
assignment=self.assignments["first"].key,
messages=[
models.Message(kind='file_contents',
contents={"trends.py": ""})
],
),
"second":
models.Backup(
submitter=self.accounts["student1"].key,
assignment=self.assignments["first"].key,
messages=[
models.Message(kind='file_contents',
contents={"trends.py": ""})
],
),
"third":
models.Backup(
submitter=self.accounts["student2"].key,
assignment=self.assignments["first"].key,
messages=[
models.Message(kind='file_contents',
contents={"trends.py": ""})
],
),
}
for backup in self.backups.values():
backup.put()
async def handle(self, topic: str, payload: Dict):
db = SessionLocal()
try:
parts = topic.split("/")
if len(parts) < 2 or parts[0] != "moca":
return
# moca/...
if parts[1] == "via" and len(parts) >= 5:
# data from a service (e.g. moca-service-telegram)
# example: moca/via/telegram/4/contacts --> add or update contact(s)
service: str = parts[2]
connector_id: int = int(parts[3])
command: str = parts[4]
connector = crud.get_connector_by_connector_id(
db, service, connector_id)
if not connector:
return
if command == "contacts":
for contact_data in payload:
internal_contact_id = contact_data.get("contact_id")
contact = models.Contact(
contact_id=crud.get_id(connector.connector_id,
internal_contact_id),
internal_id=internal_contact_id,
service_id=service,
name=contact_data.get("name"),
username=contact_data.get("username"),
phone=contact_data.get("phone"),
avatar=None,
connector_id=connector.connector_id,
)
db.merge(contact)
db.commit()
elif command == "chats":
for chat_data in payload:
internal_chat_id = chat_data.get("chat_id")
chat = models.Chat(
chat_id=crud.get_id(connector.connector_id,
internal_chat_id),
connector_id=connector.connector_id,
internal_id=internal_chat_id,
name=chat_data.get("name"),
is_muted=False,
is_archived=False,
)
db.merge(chat)
db.commit()
chat_id = chat.chat_id
last_message = chat_data.get("last_message")
if last_message:
# Get contact of the sender, else ask for it
internal_contact_id = last_message.get(
"contact_id")
# check if contact exists, else request contact
maybe_contact = crud.get_contact_from_connector(
db,
connector.user_id,
connector.connector_id,
internal_contact_id,
)
if not maybe_contact:
contact = await self.get_contact(
connector.connector_type,
connector.connector_id,
internal_contact_id,
)
new_contact = models.Contact(
contact_id=crud.get_id(
connector.connector_id,
internal_contact_id),
internal_id=internal_contact_id,
service_id=connector.connector_type,
connector_id=connector.connector_id,
name=contact.get("name"),
username=contact.get("username"),
phone=contact.get("phone"),
avatar=contact.get("avatar"),
is_self=False,
)
db.merge(new_contact)
db.commit()
contact_id = new_contact.contact_id
else:
contact_id = maybe_contact.contact_id
# TODO: Reimplement last message
# new_last_message = models.Message(
# message_id=last_message.get("message_id"),
# contact_id=contact_id,
# internal_id=chat_id,
# message=json.dumps(last_message.get("message")),
# sent_datetime=datetime.fromisoformat(last_message.get("sent_datetime"))
# )
# db.merge(new_last_message)
# db.commit()
participants = chat_data.get("participants")
if participants:
for participant in participants:
c = crud.get_contact_from_connector(
db,
connector.user_id,
connector.connector_id,
participant,
)
if not c:
contact = await self.get_contact(
connector.connector_type,
connector.connector_id,
participant,
)
c = models.Contact(
contact_id=crud.get_id(
connector.connector_id,
participant),
internal_id=participant,
service_id=connector.connector_type,
connector_id=connector.connector_id,
name=contact.get("name"),
username=contact.get("username"),
phone=contact.get("phone"),
avatar=contact.get("avatar"),
is_self=False,
)
db.merge(c)
db.commit()
db.merge(
models.ContactsChatsRelationship(
contact_id=c.contact_id,
chat_id=chat_id))
try:
db.commit()
except sqlalchemy.exc.IntegrityError:
db.rollback()
elif command == "messages":
for message_data in payload:
# Get contact of the sender, else ask for it
internal_contact_id = message_data.get("contact_id")
# check if contact exists, else request contact
c = crud.get_contact_from_connector(
db,
connector.user_id,
connector.connector_id,
internal_contact_id,
)
if not c:
contact = await self.get_contact(
connector.connector_type,
connector.connector_id,
internal_contact_id,
)
c = models.Contact(
contact_id=crud.get_id(connector.connector_id,
internal_contact_id),
internal_id=internal_contact_id,
service_id=connector.connector_type,
connector_id=connector.connector_id,
name=contact.get("name"),
username=contact.get("username"),
phone=contact.get("phone"),
avatar=contact.get("avatar"),
is_self=False,
)
db.merge(c)
db.commit()
else:
pass
chat = (db.query(models.Chat).filter(
models.Chat.connector_id == connector_id,
models.Chat.internal_id == message_data.get(
"chat_id"),
).first())
if not chat:
chat = models.Chat(
chat_id=crud.get_id(
connector.connector_id,
message_data.get("chat_id")),
connector_id=connector_id,
internal_id=message_data.get("chat_id"),
name="Loading...",
is_muted=False,
is_archived=False,
)
db.merge(chat)
db.commit()
new_last_message = models.Message(
message_id=crud.get_message_id(
connector.connector_id,
message_data.get("message_id"), chat.chat_id),
internal_id=message_data.get("message_id"),
contact_id=crud.get_id(connector.connector_id,
internal_contact_id),
chat_id=chat.chat_id,
message=json.dumps(message_data.get("message")),
sent_datetime=datetime.fromisoformat(
message_data.get("sent_datetime").split("Z")
[0]),
)
db.merge(new_last_message)
db.commit()
finally:
db.close()
def mutate(root, info, content, user_id, section_id):
new_message = models.Message(content=content, user_id=user_id, section_id=section_id)
db.session.add(new_message)
db.session.commit()
return NewMessageMutation(message=new_message)
