def save_message(self, message_data):
chunks, chunk_size = len(
message_data['message']
), _model_field_limits['Message__message__max_length']
message_chunks = [
message_data['message'][i:i + chunk_size]
for i in range(0, chunks, chunk_size)
]
first_message_chunk = message_chunks.pop(0)
with transaction.atomic():
message = ChatMessage(chat_room_id=self.room_id,
user_id=self.user_id,
datetime=datetime.fromisoformat(
message_data['datetime']),
message=first_message_chunk)
message.save()
parent_message_id = message.pk
for message_chunk in message_chunks:
message = ChatMessage(chat_room_id=self.room_id,
user_id=self.user_id,
datetime=datetime.fromisoformat(
message_data['datetime']),
message=first_message_chunk,
parent_message_id=parent_message_id)
message.save()
def new_message(channel, data):
simple_text = data.get('text', '')
comment_regex = r'^\s*{}'.format(CHAT_COMMENT_TAG)
if not re.match(comment_regex, simple_text):
user, c = ChatUser.objects.get_or_create(user_id=data['user'])
m = ChatMessage(data=json.dumps(data), user=user, channel=channel)
m.save()
def new_message(request):
''' функция для создания нового сообщения'''
if request.user.is_authenticated() and request.method == 'POST':
companion_id = request.POST["companion_id"]
author_id = int(request.POST["author_id"])
message_text = request.POST["message_text"]
author = request.user
if author_id == request.user.person_id:
companion = MyUser.objects.get(person_id=companion_id)
else:
companion = MyUser.objects.get(person_id=author_id)
try:
#проверяем существует ли беседа между текущими пользователями. Так как в модели chat установлено, что author и companion должны быть уникальными, то если в текущем блоке try не возникает исключения, создаем новую беседу.
chat = Chat(author=author,
companion=companion,
user_last_change=request.user)
chat.save()
print('new_chat')
except:
#если беседа существует, находим её, правильно определив кто является автором, а кто собеседником
chat = Chat.objects.filter(author=author, companion=companion)
if not len(chat):
chat = Chat.objects.filter(companion=author,
author=companion)[0]
else:
chat = chat[0]
message = ChatMessage(chat=chat, user=author, text=message_text)
message.save()
return redirect(request.META["HTTP_REFERER"])
else:
return HttpResponse('ВЫ не авторизировались.')
def setUp(self):
""" Create necessary instances before tests """
self.rental = Rental(address='11 Test Street')
self.maint_request = MaintRequest(property_ref=self.rental)
self.chat_message = ChatMessage(maint_request=self.maint_request,
message='A test message')
def test_chat_message_save(self):
"""Tests the save of the instance in redis"""
for i in range(100):
cm = ChatMessage(uuid.uuid4(), "default")
cm.msg = "Python rulz!%d" % i
cm.user = "******" % i
cm.time = time.time()
cm.save()
def test_chat_message_basic(self):
"""Tests creation, getters and setter of ChatMessage model"""
cm = ChatMessage(uuid.uuid4(), "default")
cm.msg = "Python rulz!"
cm.user = "******"
cm.time = time.time()
self.assertEqual(cm.msg, "Python rulz!")
self.assertEqual(cm.user, "slok")
async def send_message(self, text_data):
user = text_data['payload']['user']
message = text_data['payload']['message']
db_message = ChatMessage(user=user, message=message)
db_message.save()
# Send message to room group
await self.channel_layer.group_send(self.room_group_name, {
'type': 'chat_message',
'message': message,
'user': user
})
def execute(self):
expire_date = datetime.now() - timedelta(seconds=settings.CHAT_TIMEOUT)
appearances = Appearance.objects.filter(timestamp__lte=expire_date)
for appearance in appearances:
# generate leave messages in each room
m = ChatMessage()
m.room = appearance.room
m.type = ChatMessage.LEAVE
m.author = appearance.person
m.save()
appearances.delete()
def test_chat_message_find(self):
"""Tests the find of the instance in redis"""
uuid_id = uuid.uuid4()
cm = ChatMessage(uuid_id, "default")
cm.msg = "Python rulz!"
cm.user = "******"
cm.time = time.time()
cm.save()
cm_find = ChatMessage.find(uuid_id)
self.assertEqual(cm_find.msg, cm.msg)
self.assertEqual(cm_find.user, cm.user)
self.assertEqual(cm_find.room, cm.room)
def test_chat_messages(self):
"""Tests the find of the instance in redis"""
for i in range(30):
uuid_id = uuid.uuid4()
cm = ChatMessage(uuid_id, "room1")
cm.msg = "Python rulz!%d" % i
cm.user = "******" % i
cm.time = time.time()
cm.save()
cr = ChatRoom("room1")
messages = cr.messages(10)
self.assertEqual(len(messages), 10)
name_number = 20
for i in messages:
self.assertEqual(i.user, "slok%d" % name_number)
name_number += 1
def ajax_say(request):
room = get_obj_from_request(request.POST, 'room', ChatRoom)
if room is None:
return json_failure(design.bad_room_id)
data = {
'user': {
'is_authenticated': request.user.is_authenticated(),
'permission_read': room.permission_to_hear(request.user),
'permission_write': room.permission_to_chat(request.user),
},
'success': False,
}
if not room.is_active():
return json_failure(design.room_is_not_active)
message = request.POST.get('message', '')
if message == "":
return json_failure(design.cannot_say_blank_message)
if len(message) > ChatMessage._meta.get_field('message').max_length: #@UndefinedVariable
return json_failure(design.message_too_long)
if not data['user']['permission_write']:
return json_failure(design.you_lack_write_permission)
msgType = get_val(request.POST, 'type', ChatMessage.MESSAGE)
if msgType not in [ChatMessage.MESSAGE, ChatMessage.ACTION]:
msgType = ChatMessage.MESSAGE
# we're clear. add the message
m = ChatMessage()
m.room = room
m.type = msgType
m.author = request.user
m.message = message
m.save()
data['success'] = True
return json_response(data)
def send_message(request, chatroom_id):
chatroom = ChatRoom.objects.get(pk=chatroom_id)
if request.user not in chatroom.users.all():
data = {
'message': "You do not have permission to post in this room.",
'success': False
}
return HttpResponse(json.dumps(data), status=401)
post_data = json.loads(request.body.decode('utf-8'))
if 'message' not in post_data:
data = {'message': "No message supplied.", 'success': False}
return HttpResponse(json.dumps(data), status=400)
message = ChatMessage(user=request.user,
room=chatroom,
text=post_data['message'])
message.save()
return HttpResponse(json.dumps({'success': True}))
def message_handler(request):
if request.method == "POST":
# add new message
json_data = json.loads(request.body)
message = json_data.get('message')
if message:
msg = ChatMessage(created_by=request.user, message=message)
msg.save()
return JsonResponse({'success': True, 'message': 'ok'})
if request.method == "GET":
# return messages of public channel limit by 100
offset = request.GET.get('offset')
if not offset:
offset = 0
raw_sql = "SELECT * FROM chat_chatmessage"
# "users_user au on cm.created_by_id = au.id" \
# "(select last_cleared FROM chat_chatclear where cleared_by_id=" + str(
# request.user.id) + ") order by " \
# "created_on limit 100 offset " + str(offset) + ";"
chat_messages = db.get_all_messages(raw_sql)
return JsonResponse({'success': True, 'data': chat_messages})
def ajax_hear(request):
"""
get new or all messages
"""
last_message_str = request.GET.get('last_message', 'null')
room = get_obj_from_request(request.GET, 'room', ChatRoom)
if room is None:
return json_failure(design.bad_room_id)
# make sure user has permission to be in this room
data = {
'user': {
'is_authenticated': request.user.is_authenticated(),
'permission_read': room.permission_to_hear(request.user),
'permission_write': room.permission_to_chat(request.user),
},
'room': room.to_dict(),
'messages': [],
'success': True
}
if request.user.is_authenticated():
data['user'].update({
'username': request.user.username,
})
if data['user']['permission_read']:
def add_to_message(msg):
return {
'id': msg.id,
'type': msg.type,
'author': {
'username': msg.author.username,
'id': msg.author.id,
},
'message': msg.message,
'timestamp': msg.timestamp,
}
if last_message_str == 'null':
# get entire log for this chat.
data['messages'] = [add_to_message(x) for x in ChatMessage.objects.filter(room=room)]
else:
try:
last_message_id = int(last_message_str)
except ValueError:
last_message_id = 0
data['messages'] = [add_to_message(x) for x in ChatMessage.objects.filter(room=room, id__gt=last_message_id)]
if data['user']['permission_write']:
# mark an appearance in the ChatRoom
if request.user.is_authenticated() and room.is_active():
appearances = Appearance.objects.filter(person=request.user, room=room)
if appearances.count() > 0:
appearances[0].save() # update the timestamp
else:
new_appearance = Appearance()
new_appearance.room = room
new_appearance.person = request.user
new_appearance.save()
# join message
m = ChatMessage()
m.room=room
m.type=ChatMessage.JOIN
m.author=request.user
m.save()
return json_response(data)
def save_message(self, message, user):
"""Сохранение нового сообщения в БД."""
new_message = ChatMessage(user=user, group=self.group, message=message)
new_message.save()
def save_message(self, message, user):
m = ChatMessage(user=user, group=self.group, message=message)
m.save()
def log_message_sync(message, m_type, url, language):
m = ChatMessage(text=message, message_type=m_type, speech_url=url, language=language)
return m.save()
def show_all_my_chats(request):
''' функция для отображения страницы с беседами и обработки ajax-запросов по извлечению сообщений, а также добавлению новых.'''
if request.user.is_authenticated():
if request.method == 'GET':
#определяем все беседы авторизированного пользователя
my_friends, count_friends = all_friends(request.user)
new_friends = MyFriends.objects.filter(friend=request.user,
status=0)
count_new_friends = MyFriends.objects.filter(friend=request.user,
status=0).count()
count_my_photos = UserPhoto.objects.filter(
user=request.user).count()
all_chats, count_my_chats = my_chats(request.user)
return render(
request, 'my_chats.html', {
'person': request.user,
'my_friends': my_friends,
'new_friends': new_friends,
'count_new_friends': count_new_friends,
'count_my_friends': count_friends,
'person_friends': my_friends,
'count_friends': count_friends,
'count_my_photos': count_my_photos,
'all_chats': all_chats,
'count_my_chats': count_my_chats
})
#обрабатываем ajax-запросы в различных режимах
if request.is_ajax():
mode = request.POST["mode"]
if mode == '0':
#определяем все сообщения запрошенной беседы и передаём её в виде строки html-кода
chat_id = request.POST["chat_id"]
chat = Chat.objects.get(id=chat_id)
messages = ChatMessage.objects.filter(chat=chat)
ajax_response = render_to_string('chat_messages.html', {
'message': messages,
'user': request.user
})
return HttpResponse(ajax_response)
elif mode == '1':
#добавляем новое сообщение и извлекаем сообщения из базы со временем размещения больше последнего обновления. Возвращаем новую дату обновления и сообщения в виде строки html-кода.
text_message = request.POST["message_text"]
chat_id = request.POST["chat_id"]
chat = Chat.objects.get(id=chat_id)
new_message = ChatMessage(chat=chat,
user=request.user,
text=text_message)
new_message.save()
chat.user_last_change = request.user
chat.save()
old_date = datetime.datetime.strptime(
request.POST['last_date'], '%d-%m-%Y %H:%M:%S.%f')
new_date = chat.last_change
new_date = new_date.strftime('%d-%m-%Y %H:%M:%S.%f')
all_new_messages = ChatMessage.objects.filter(
chat=chat, date__gt=old_date)
ajax_response = render_to_string('chat_messages.html', {
'message': all_new_messages,
'user': request.user
})
data = {'new_date': new_date, 'ajax_response': ajax_response}
return HttpResponse(json.dumps(data),
content_type='application/json')
elif mode == '2':
#автоматический опрос на наличие новых записей, отправляется раз в 5 сек со стороны клиента. Возвращаем новую дату обновления и сообщения в виде строки html-кода.
try:
chat_id = request.POST["chat_id"]
chat = Chat.objects.get(id=chat_id)
old_date = datetime.datetime.strptime(
request.POST['last_date'], '%d-%m-%Y %H:%M:%S.%f')
new_date = chat.last_change
new_date = new_date.strftime('%d-%m-%Y %H:%M:%S.%f')
all_new_messages = ChatMessage.objects.filter(
chat=chat, date__gt=old_date)
ajax_response = render_to_string('chat_messages.html', {
'message': all_new_messages,
'user': request.user
})
data = {
'new_date': new_date,
'ajax_response': ajax_response
}
except Exception as err:
print(err)
return HttpResponse(ajax_response)
else:
return HttpResponse("Вы не авторизированы")
def test_chat_message_delete(self):
"""Tests the delete of the instance in redis"""
with self.assertRaises(NotImplementedError):
cm = ChatMessage(uuid.uuid4(), "default")
cm.delete()
