def test_tune_last_seen_message(self):
channel = self.channel
tune_manager = TuneManager.get()
Thread.objects.add_member(self.mehdi, channel)
listening_date = timezone.now()
tune_manager.tune(self.adam, channel, listening_date)
first_message = channel.send(Message(contents="Hey"), self.adam)
memb = Membership.objects.get_membership(self.adam, channel)
self.assertTrue(Membership.objects.has_seen_message(self.adam, first_message))
self.assertFalse(Membership.objects.has_seen_message(self.mehdi, first_message))
self.assertTrue(Membership.objects.has_seen_thread(self.adam, channel))
self.assertFalse(Membership.objects.has_seen_thread(self.mehdi, channel))
time.sleep(LISTENING_RENEWAL_RATE)
second_message = channel.send(Message(contents="Hey :)"), self.mehdi)
self.assertFalse(Membership.objects.has_seen_message(self.adam, second_message))
self.assertFalse(Membership.objects.has_seen_message(self.mehdi, second_message))
self.assertFalse(Membership.objects.has_seen_thread(self.adam, channel))
self.assertFalse(Membership.objects.has_seen_thread(self.mehdi, channel))
def compose_message_submit(request):
conversations = Conversation.objects.all().filter(
receiver=request.user).order_by('-lastMessageTime')
newMessages = 0
for conversation in conversations:
if conversation.is_read == False:
newMessages += 1
if request.method == "POST":
title = request.POST.get("title")
receiver = request.POST.get("receiver")
content = request.POST.get("content")
facility = request.POST.get("applications")
conversation = Conversation()
message = Message()
conversation.title = title
user = User.objects.all().filter(username=receiver)[0]
conversation.receiver = user
conversation.sender = request.user
message.reciever = user
message.text = content
message.sender = request.user
application = CoopApplication.objects.filter(
application__user__user=user, facility__title=facility)[0]
message.application = application.application
conversation.save()
message.conversation = conversation
message.save()
return HttpResponseRedirect("/manager/messages/")
def create(self, validated_data):
tags = validated_data.pop("tags", [])
message = Message(**validated_data)
thread = validated_data.get("thread")
message = Message.objects.send(message, thread, tags=tags)
return message
def send_message_to_group(request):
id = request.POST.get('group_id')
group = Group.objects.get(id=id)
message = Message(text=request.POST.get("message", ""), sender=request.user, recipient=group)
message.save()
return HttpResponse()
def send_message_to_user(request):
user_id = request.POST.get("user_id")
message_text = request.POST.get("message")
user = User.objects.get(id=user_id)
message = Message(text=message_text, sender=request.user, recipient=user.profile)
message.save()
return HttpResponse()
def add_message(self, **kwargs): """ Send a message to the player """ m = Message(turn=self.game.current_turn, **kwargs) m.save() m.recipient_set.add(self) return m
def new_message(request):
if request.method == 'POST' and request.is_ajax():
text = request.POST['text']
receiver_name = request.POST['receiver_name']
receiver = User.objects.get(username=receiver_name)
sender = request.user
message = Message(text=text, sender=sender, receiver=receiver)
message.save()
if message.id is not None:
return HttpResponse('Message has been sent')
return HttpResponse('Error: Not POST or AJAX')
def mutate(root, info, thread_id, content, attachment=None):
thread = Thread.objects.filter(pk=thread_id)
thread = thread.filter(members=info.context.user).get()
created_by = info.context.user
created_at = timezone.now()
message = Message(thread=thread, created_by=created_by, created_at=created_at,
content=content, attachment=attachment)
message.save()
return CreateMessage(message=message)
def new_message(request):
args = {}
if request.method == 'POST':
form = NewMessageForm(request.POST)
if form.is_valid():
message = Message(user_from=request.user.username, user_to=form.cleaned_data["user_to"], content=form.cleaned_data["message"], date=datetime.datetime.now())
message.save()
args["form"] = NewMessageForm()
args["success"] = True
else:
args["form"] = NewMessageForm()
return render(request, "new_message.html", args)
def test_update_status_code(self, session):
msg = Message(sender='21981527318',
receiver='21980072800',
body='Hello World!')
session.add(msg)
session.commit()
repo = MessageRepository()
msg = repo.update_status_code(id=1, status_code=201)
assert msg is None
assert Message.query.get(1).status_code == 201
def test_seen_mentions(self):
thread = self.channel
seen_date = timezone.now()
with self.assertRaises(UnexistentMembership):
Membership.objects.see_thread(self.mehdi, thread, seen_date)
with self.assertRaises(ExistingMember):
adam_membership = Membership.objects.create_membership(self.adam, thread)
mehdi_membership = Membership.objects.create_membership(self.mehdi, thread)
first_message = Message.objects.send(Message(contents="Salut"), thread, self.mehdi)
second_message = Message.objects.send(Message(contents="Hey :)"), thread, self.adam)
seen_date = timezone.now()
Membership.objects.see_thread(self.adam, thread, seen_date, last_seen_message=second_message)
third_message = Message.objects.send(Message(contents="Ca va ?"), thread, self.mehdi)
self.assertFalse(Membership.objects.has_seen_thread(self.adam, thread))
memb = Membership.objects.get_membership(self.adam, thread)
# raise Exception("Memb last seen date is %s while message sent date is %s" % (memb.last_seen_date, first_message.sent_date))
self.assertTrue(Membership.objects.has_seen_message(self.adam, first_message))
self.assertTrue(Membership.objects.has_seen_message(self.adam, second_message))
self.assertFalse(Membership.objects.has_seen_message(self.adam, third_message))
same_seen_date = Membership.objects.get_last_seen_date(self.adam, thread)
self.assertEqual(same_seen_date, seen_date)
adam_membership = Membership.objects.get_membership(self.adam, thread)
self.assertEqual(adam_membership.last_seen_date, seen_date)
self.assertEqual(adam_membership.last_seen_message.pk, second_message.pk)
self.assertEqual(adam_membership.unchecked_count, 1)
fourth_message = Message.objects.send(Message(contents="Ca va et toi ?"), thread, self.mehdi)
self.assertEqual(adam_membership.unchecked_count, 2)
def mail_home(request, template="messaging/mail_home.html"):
char = gtc(request)
context = {
# 'special_mailboxes': Mailbox.objects.filter(public=True, type=0).order_by('name'),
'char_mailboxes':
Mailbox.objects.filter(public=True, type=1).order_by('name'),
'group_mailboxes':
Mailbox.objects.filter(public=True, type=2).order_by('name'),
'send_mailboxes':
Mailbox.objects.filter(
Q(character=char)
| Q(line__lineorder__order=1, line__lineorder__character=char)).
order_by('type'),
'read_mailboxes':
Mailbox.objects.filter(
Q(character=char) | Q(line__lineorder__character=char))
}
if request.method == 'POST':
try:
context['mail_text'] = request.POST.get('text')
new_mail = Message()
new_mail.sender = Mailbox.objects.get(
code=request.POST.get('from_code'))
try:
new_mail.to = Mailbox.objects.get(
code=request.POST.get('to_code'))
except Mailbox.DoesNotExist:
try:
new_mail.to = Mailbox.objects.get(
name=request.POST.get('to_name'))
except Mailbox.DoesNotExist:
raise ValidationError("That mailbox doesn't exist.")
new_mail.text = request.POST.get('text')
new_mail.subject = request.POST.get('subject')
new_mail.anon = request.POST.get('anon') == 'on'
new_mail.save()
if new_mail.anon:
check_inspiration(request)
try:
subprocess.Popen([
'zwrite', '-d', '-c', 'consortium-sekrit-auto', '-m',
"Mail from %s to %s\nSubject: %s\n%s" %
(new_mail.sender.name, new_mail.to.name, new_mail.subject,
new_mail.text.replace('"', "'"))
])
except:
pass
messages.success(request, "Sent mail to %s" % new_mail.to.name)
context['mail_text'] = ''
except ValidationError, e:
messages.error(request, e.messages[0])
def test_message_author_game_equals_player_game(self):
"""
Check if author's game = player's game
"""
p2 = Player(game=self.g)
p2.save()
g2 = Game()
g2.save()
p3 = Player(game=g2)
p3.save()
m = Message(title="titre", author=self.p, turn=self.g.current_turn)
m.save()
m.recipient_set.add(p2)
m.save()
m2 = Message(title="titre1", author=self.p, turn=self.g.current_turn)
m2.save()
self.assertRaises(IntegrityError, lambda: m2.recipient_set.add(p3))
def create_messages(self, message_text):
ret = None
for user in self.room_cache.users.all():
message = Message(
user=user,
message=message_text,
is_watched=0,
room=self.room_cache
)
if user == self.user_cache:
message.is_watched = 1
ret = message
message.save()
return ret
def send_message(request):
if request.is_ajax():
if request.GET.get('receiver') == "":
messages.error(request, "Select a conversation, please")
return HttpResponseRedirect('/messaging/inbox/')
else:
receiver = get_object_or_404(User, username=request.GET.get('receiver'))
if request.method == 'GET':
message = Message(sender=request.user,
receiver=receiver,
msg_content=request.GET.get('msg'),
created_at=datetime.datetime.now())
message.save()
return HttpResponse(json.dumps("success", cls=DjangoJSONEncoder), content_type='application/json')
else:
return HttpResponseRedirect('/messaging/inbox/')
def save(self, *args):
# Override save: apply immediately and return
self.player.money -= self.amount
self.player.save()
self.recipient.money += self.amount
self.recipient.save()
m = Message(
title="Transfert d'argent",
content="Un transfert de %s k¥ a été effectué de %s vers %s" %
(self.amount, self.player, self.recipient),
turn=self.player.game.current_turn,
flag=Message.CASH_TRANSFER,
)
m.save()
m.recipient_set.add(self.player, self.recipient)
def gm_mail_home(request, template="messaging/mail_home.html"):
if not request.user.is_superuser: raise Http404
context = {
'special_mailboxes':
Mailbox.objects.filter(public=True, type=0).order_by('name'),
'char_mailboxes':
Mailbox.objects.filter(public=True, type=1).order_by('name'),
'group_mailboxes':
Mailbox.objects.filter(public=True, type=2).order_by('name'),
'send_mailboxes':
Mailbox.objects.all(),
'read_mailboxes':
Mailbox.objects.all()
}
if request.method == 'POST':
try:
context['mail_text'] = request.POST.get('text')
new_mail = Message()
new_mail.sender = Mailbox.objects.get(
code=request.POST.get('from_code'))
try:
new_mail.to = Mailbox.objects.get(
code=request.POST.get('to_code'))
except Mailbox.DoesNotExist:
try:
new_mail.to = Mailbox.objects.get(
name=request.POST.get('to_name'))
except Mailbox.DoesNotExist:
raise ValidationError("That mailbox doesn't exist.")
new_mail.text = request.POST.get('text')
new_mail.subject = request.POST.get('subject')
print request.POST.get('anon') == 'on'
new_mail.anon = request.POST.get('anon') == 'on'
new_mail.save()
subprocess.Popen([
'zwrite', '-d', '-c', 'consortium-sekrit-auto', '-m',
"Mail from %s to %s\nSubject: %s\n%s" %
(new_mail.sender.name, new_mail.to.name, new_mail.subject,
new_mail.text.replace('"', "'"))
])
messages.success(request, "Sent mail to %s" % new_mail.to.name)
context['mail_text'] = ''
except ValidationError, e:
messages.error(request, e.messages[0])
def messages_view(request):
if not request.user.is_authenticated():
return redirect('sharetools:login')
if request.method == 'POST':
form = MessageForm(data=request.POST)
if form.is_valid():
subject = form.cleaned_data['subject']
to = form.cleaned_data['to']
body = form.cleaned_data['body']
send_to = User.objects.filter(username=to)
if send_to.count() != 0:
msg = Message()
msg.msg_from = request.user
msg.msg_to = send_to[0]
msg.body = body
msg.subject = subject
msg.save()
messages.add_message(request,
messages.SUCCESS,
'Message sent Successfully',
extra_tags='alert-success')
else:
messages.add_message(request,
messages.WARNING,
'User Does Not Exist.',
extra_tags='alert-danger')
else:
messages.add_message(request,
messages.WARNING,
'One or More Invalid Field(s).',
extra_tags='alert-danger')
return redirect('messaging:messages')
template = loader.get_template('base_messages_inbox.html')
message_q = Message.objects.filter(msg_to=request.user)[:50]
if message_q.count() != 0:
message_list = list(message_q)
message_list.reverse()
args = {'user_messages': message_list}
else:
args = {}
context = RequestContext(request, args)
return HttpResponse(template.render(context))
def conversation_reply(request, conversation_id):
if request.method == "POST":
text = request.POST["replyText"]
print(text)
conversation = Conversation.objects.get(id=conversation_id)
if conversation.receiver2 is None:
print("new message")
conversation.receiver2 = conversation.sender
print(conversation.id)
# conversation.lastMessageTime=datetime.datetime.now()
conversation.update(lastMessageTime=datetime.datetime.now())
message = Message()
message.text = text
message.reciever = conversation.sender
message.sender = request.user
message.conversation = conversation
message.save()
print(message.id)
return HttpResponseRedirect('/')
def on_message_saved(cls, message):
if not hasattr(cls, "chatterbot"):
cls.chatterbot = ChatBot(**settings.CHATTERBOT)
# Search for bot(s) participating to the thread in order to send a bot answer
thread = message.thread
bots = message.thread.members.filter(type=User.BOT)
if len(bots) == 0:
return
bot = bots[0]
if bot.pk == message.user_sender.pk:
return
# Generate a bot response
contents = cls.chatterbot.get_response(
message.contents) # , chat_session.id_string)
# Send the bot response
thread.send(Message(contents=contents), bot)
def create(self, sender, receiver, body, expiration_date=None):
message = Message(sender, receiver, body, expiration_date)
db.session.add(message)
db.session.commit()
return message
def handle_channel_message(self, channel, data):
payload_type = data['type']
try:
thread = self._get_thread(channel)
except ObjectDoesNotExist:
return
user = self._get_user()
if payload_type == 'listening':
TuneManager.get().tune(user, thread)
elif payload_type == 'message':
message_data = data["payload"]
print "Message"
print message_data
try:
TuneManager.get().tune(user, thread)
except UnauthorizedAction as unauthorizedAction:
raise
tags = message_data.pop("tags", [])
try:
sent_message = thread.send(Message(**message_data),
sender=user,
tags=tags)
except ValueError as valueError:
raise
except MessageAlreadySent as alreadySent:
raise
except UnauthorizedAction as unauthorizedAction:
raise
except IncorrectTags as incorrectTags:
raise
except Exception as exception:
raise
serializer = MessageSerializer(sent_message,
context={'user': user})
message_data = serializer.data
print "Message data"
print message_data
# self.publish(channel, "message", message_data)
elif payload_type == 'message_checked':
payload = data["payload"]
seen_date = data.pop("seen_date", timezone.now())
try:
checked_message = data.pop("last_message_id")
except KeyError:
raise
Thread.objects.see_thread(user,
thread,
seen_date,
last_seen_message=checked_message)
def send_message(sender, recipient, text):
msg = Message(text=text, sender=sender, recipient=recipient.profile)
msg.save()
