Пример #1
0
 def save(self, sender, parent_msg=None):
     recipients = self.cleaned_data['recipient']
     subject = self.cleaned_data['subject']
     body = self.cleaned_data['body']
     message_list = []
     final_recipients = set()
     for r in recipients:
         if isinstance(r, User):
             final_recipients.add(r)
         elif isinstance(r, Group):
             [final_recipients.add(u) for u in r.user_set.all()]
         else:
             raise NotImplementedError
     for r in final_recipients:
         msg = Message(
             sender = sender,
             recipient = r,
             subject = subject,
             body = body,
         )
         if parent_msg is not None:
             msg.parent_msg = parent_msg
             parent_msg.replied_at = datetime.datetime.now()
             parent_msg.save()
         msg.save()
         message_list.append(msg)
         if notification:
             if parent_msg is not None:
                 notification.send([sender], "messages_replied", {'message': msg,})
                 notification.send([r], "messages_reply_received", {'message': msg,})
             else:
                 notification.send([sender], "messages_sent", {'message': msg,})
                 notification.send([r], "messages_received", {'message': msg,})
     return message_list
Пример #2
0
def send_message(request,msg_body,msg_subject,msg_receiver):
  '''
        JSON-RPC view : meow.sendMsg
        
        Returns True, if the currently authenticated user is successful in sending the message.

	Inbound parameters: test string 'msg_body' & 'msg_subject'. text string 'msg_receiver' shld
	be username of MEOW user.

	Requires authentication to call this function.
  '''
 
  try:
	   logging.debug('start meow.sendMsg with %s %s %s ' %  (msg_body,msg_subject,msg_receiver))
	   msg_receiver_user = User.objects.all().filter(username=msg_receiver)
	   if len(msg_receiver_user) != 1:
		return False
	   msg_receiver_user = msg_receiver_user[0]
	   logging.debug(" MSG %s %s %s %s " % (request.user, msg_receiver_user, msg_subject, msg_body))
	   msg = Message(
				sender = request.user,
				recipient = msg_receiver_user,
				subject = msg_subject,
				body = msg_body,
			    )
	   msg.save()
	   return True
  except:
	logging.error('meow.sendMsg got exception')
	return False
Пример #3
0
 def save(self, sender, parent_msg=None):
     recipients = self.cleaned_data['recipient']
     subject = self.cleaned_data['subject']
     body = self.cleaned_data['body']
     message_list = []
     for r in recipients:
         msg = Message(
             sender = sender,
             recipient = r,
             subject = subject,
             body = body,
         )
         if parent_msg is not None:
             msg.parent_msg = parent_msg
             parent_msg.replied_at = datetime.datetime.now()
             parent_msg.save()
         msg.save()
         message_list.append(msg)
         if notification:
             if parent_msg is not None:
                 notification.send([sender], "messages_replied", {'message': msg,})
                 notification.send([r], "messages_reply_received", {'message': msg,})
             else:
                 notification.send([sender], "messages_sent", {'message': msg,})
                 notification.send([r], "messages_received", {'message': msg,})
     return message_list
Пример #4
0
def send_reply(request,msg_body,msg_subject,msg_receiver,parent_id):
  '''
        JSON-RPC view : meow.sendMsgReply
        
        Returns True, if the currently authenticated user is successful in sending the reply message.
	
	Inbound parameters: test string 'msg_body' & 'msg_subject'. text string 'msg_receiver' shld
        be username of MEOW user, 'parent_id' shld be the msg id of an existing mesage.

	Requires authentication to call this function.
  '''
 
  try:
	   logging.debug('start meow.sendMsgReply with %s %s %s %d ' %  (msg_body,msg_subject,msg_receiver, parent_id))
	   msg_receiver_user = User.objects.all().filter(username=msg_receiver)
	   if len(msg_receiver_user) != 1:
		return False
	   msg_receiver_user = msg_receiver_user[0]
	   logging.debug(" MSG %s %s %s %s  %d" % (request.user, msg_receiver_user, msg_subject, msg_body,parent_id))
	   msg = Message(
				sender = request.user,
				recipient = msg_receiver_user,
				subject = msg_subject,
				body = msg_body,
			    )
	   parent_msg_obj = Message.objects.filter(id=parent_id)
	   if (len(parent_msg_obj)!=1):
		return False
	   msg.parent_msg=parent_msg_obj[0]
	   msg.save()
	   return True
  except:
	logging.error('meow.sendMsgReply got exception')
	return False
Пример #5
0
class SendTestCase(TestCase):
    fixtures = ['uploadeXe/fixtures/initial-model-data.json']
    def setUp(self):
        self.user1 = User.objects.create_user('user1', '*****@*****.**', '123456')
        self.user2 = User.objects.create_user('user2', '*****@*****.**', '123456')
	
	adminrole=Role.objects.get(pk=1)
	self.user1_role=User_Roles(name="test", user_userid=self.user1, role_roleid=adminrole)
	self.user1_role.save()
	self.user2_role=User_Roles(name="test", user_userid=self.user2, role_roleid=adminrole)
        self.user2_role.save()
	mainorganisation = Organisation.objects.get(pk=1)
        user_organisation1 = User_Organisations(user_userid=self.user1, organisation_organisationid=mainorganisation)
        user_organisation1.save()
	user_organisation2 = User_Organisations(user_userid=self.user2, organisation_organisationid=mainorganisation)
        user_organisation2.save()


	print(User.objects.all())
	print(User_Roles.objects.all())

        self.msg1 = Message(sender=self.user1, recipient=self.user2, subject='Subject Text', body='Body Text')
        self.msg1.save()
        
    def testBasic(self):
        self.assertEqual(self.msg1.sender, self.user1)
        self.assertEqual(self.msg1.recipient, self.user2)
        self.assertEqual(self.msg1.subject, 'Subject Text')
        self.assertEqual(self.msg1.body, 'Body Text')
        self.assertEqual(self.user1.sent_messages.count(), 1)
        self.assertEqual(self.user1.received_messages.count(), 0)
        self.assertEqual(self.user2.received_messages.count(), 1)
        self.assertEqual(self.user2.sent_messages.count(), 0)
Пример #6
0
def report_spam(request, content_type_id, object_id):
    """
    Sends message and email to superuser regarding the object being flagged as spam.
    """
    ctype = get_object_or_404(ContentType, pk=content_type_id)
    object = get_object_or_404(ctype.model_class(), pk=object_id)
    sender = request.user
    r = User.objects.get(is_superuser=True)
    subject = u"Spam Report"
    body = str(request.build_absolute_uri(object.get_absolute_url()))
    msg = Message(
            sender = sender,
            recipient = r,
            subject = subject,
            body = body,
    )
    msg.save()
    if notification:
        notification.send([sender], "messages_sent", {'message': msg,})
        notification.send([r], "messages_received", {'message': msg,})

    if request.is_ajax():
        return HttpResponse('ok')
    else:
        return render_to_response('django_messages/report_spam.html', {}, RequestContext(request))
Пример #7
0
 def save(self, sender, parent_msg=None):
     recipients = self.cleaned_data['recipient']
     subject = self.cleaned_data['subject']
     body = self.cleaned_data['body']
     message_list = []
     for r in recipients:
         msg = Message(
             sender=sender,
             recipient=r,
             subject=subject,
             body=body,
         )
         if parent_msg is not None:
             msg.parent_msg = parent_msg
             parent_msg.replied_at = timezone.now()
             parent_msg.save()
         msg.save()
         message_list.append(msg)
         UserOnBoardNotification.objects.create(user=r, title="Nachricht", notify_typ="info",
                                                notify_message="Hallo, " + str(
                                                    sender) + " hat Ihnen eine Nachricht zugesendet!")
         UserOnBoardNotification.objects.create(user=sender, title="Nachricht", notify_typ="info",
                                                notify_message="Ihr Nachricht wurde erfolgreich versendet!")
         if notification:
             if parent_msg is not None:
                 notification.send([sender], "messages_replied", {'message': msg, })
                 notification.send([r], "messages_reply_received", {'message': msg, })
             else:
                 notification.send([sender], "messages_sent", {'message': msg, })
                 notification.send([r], "messages_received", {'message': msg, })
     return message_list
Пример #8
0
    def save(self, sender, parent_msg=None):
        recipients = self.cleaned_data['recipient']
        subject = self.cleaned_data['subject']
        body = self.cleaned_data['body']
        message_list = []
        msg = Message(
            sender=sender,
            recipient=recipients,
            subject=subject,
            body=body,
        )
        if parent_msg is not None:
            msg.parent_msg = parent_msg
            parent_msg.replied_at = timezone.now()
            parent_msg.save()
        msg.save()
        message_list.append(msg)

        mail_subject = '{}님이 쪽지를 보냈습니다'.format(sender.nickname)
        mail_content = '{}님의 쪽지 : {}'.format(sender.nickname, body)
        # send_mail(mail_subject, mail_content, '*****@*****.**', [recipients.email])
        send_email_message_notification.delay(mail_subject, mail_content, user_pk=recipients.pk)

        if notification:
            if parent_msg is not None:
                notification.send([sender], "messages_replied", {'message': msg,})
                notification.send([r], "messages_reply_received", {'message': msg,})
            else:
                notification.send([sender], "messages_sent", {'message': msg,})
                notification.send([r], "messages_received", {'message': msg,})
        return message_list
Пример #9
0
 def save(self, sender, parent_msg=None):
     if sender is None:
         raise ValidationError(self.error_messages['empty_sender'], code='empty_sender')
     recipients = self.cleaned_data['recipient']
     subject = self.cleaned_data['subject']
     body = self.cleaned_data['body']
     message_list = []
     for r in recipients:
         msg = Message(
             sender = sender,
             recipient = r,
             subject = subject,
             body = body,
         )
         if parent_msg is not None:
             msg.parent_msg = parent_msg
             parent_msg.replied_at = timezone.now()
             parent_msg.save()
         msg.save()
         message_list.append(msg)
         if notification:
             if parent_msg is not None:
                 notification.send([sender], "messages_replied", {'message': msg,})
                 notification.send([r], "messages_reply_received", {'message': msg,})
             else:
                 notification.send([sender], "messages_sent", {'message': msg,})
                 notification.send([r], "messages_received", {'message': msg,})
     return message_list
Пример #10
0
def send_message(request, msg_body, msg_subject, msg_receiver):
    '''
        JSON-RPC view : meow.sendMsg
        
        Returns True, if the currently authenticated user is successful in sending the message.

	Inbound parameters: test string 'msg_body' & 'msg_subject'. text string 'msg_receiver' shld
	be username of MEOW user.

	Requires authentication to call this function.
  '''

    try:
        logging.debug('start meow.sendMsg with %s %s %s ' %
                      (msg_body, msg_subject, msg_receiver))
        msg_receiver_user = User.objects.all().filter(username=msg_receiver)
        if len(msg_receiver_user) != 1:
            return False
        msg_receiver_user = msg_receiver_user[0]
        logging.debug(" MSG %s %s %s %s " %
                      (request.user, msg_receiver_user, msg_subject, msg_body))
        msg = Message(
            sender=request.user,
            recipient=msg_receiver_user,
            subject=msg_subject,
            body=msg_body,
        )
        msg.save()
        return True
    except:
        logging.error('meow.sendMsg got exception')
        return False
Пример #11
0
 def save(self, sender, parent_msg=None):
     recipients = self.cleaned_data['recipient']
     subject = self.cleaned_data['subject']
     body = self.cleaned_data['body']
     message_list = []
     for r in recipients:
         msg = Message(
             sender=sender,
             recipient=r,
             subject=subject,
             body=body,
         )
         if parent_msg is not None:
             msg.parent_msg = parent_msg
             parent_msg.replied_at = datetime.datetime.now()
             parent_msg.save()
         msg.save()
         message_list.append(msg)
         if notification:
             if parent_msg is not None:
                 notification.send([sender], "messages_replied", {
                     'message': msg,
                 })
                 notification.send([r], "messages_reply_received", {
                     'message': msg,
                 })
             else:
                 notification.send([sender], "messages_sent", {
                     'message': msg,
                 })
                 notification.send([r], "messages_received", {
                     'message': msg,
                 })
     return message_list
Пример #12
0
 def setUp(self):
     self.user1 = User.objects.create_user(
         'user1', '*****@*****.**', '123456')
     self.user2 = User.objects.create_user(
         'user2', '*****@*****.**', '123456')
     self.msg1 = Message(sender=self.user1, recipient=self.user2,
                         subject='Subject Text', body='Body Text')
     self.msg1.save()
Пример #13
0
 def setUp(self):
     self.user1 = User.objects.create_user("user3", "*****@*****.**", "123456")
     self.user2 = User.objects.create_user("user4", "*****@*****.**", "123456")
     self.msg1 = Message(sender=self.user1, recipient=self.user2, subject="Subject Text 1", body="Body Text 1")
     self.msg2 = Message(sender=self.user1, recipient=self.user2, subject="Subject Text 2", body="Body Text 2")
     self.msg1.sender_deleted_at = datetime.datetime.now()
     self.msg2.recipient_deleted_at = datetime.datetime.now()
     self.msg1.save()
     self.msg2.save()
Пример #14
0
 def setUp(self):
     self.user1 = User.objects.create_user('user3', '*****@*****.**', '123456')
     self.user2 = User.objects.create_user('user4', '*****@*****.**', '123456')
     self.msg1 = Message(sender=self.user1, recipient=self.user2, subject='Subject Text 1', body='Body Text 1')
     self.msg2 = Message(sender=self.user1, recipient=self.user2, subject='Subject Text 2', body='Body Text 2')
     self.msg1.sender_deleted_at = datetime.datetime.now()
     self.msg2.recipient_deleted_at = datetime.datetime.now()
     self.msg1.save()
     self.msg2.save()
Пример #15
0
def send_apply_messsage(recipient, message, sender):
    # subject = self.cleaned_data['subject']
    msg = Message(
        sender = sender,
        recipient = recipient,
        subject = "",
        body = message,
    )
    msg.save()
    return msg
Пример #16
0
def parish_message(request, parish_id):
    """ Panel edycji parafii dla opiekuna """
    data = {}

    parish = Parish.objects.get(pk=parish_id)
    saved = False
    form = ParishMessageForm(
        initial={'title': '%s, %s' % (parish.name, parish.place)})

    if request.method == 'POST':
        form = ParishMessageForm(request.POST)
        if form.is_valid():

            manager_exists = None
            try:
                manager_exists = ParishUser.objects.filter(
                    parish=parish, manager=True)[0].user
            except:
                pass

            from django_messages.models import Message
            message = Message()
            message.subject = form.cleaned_data['title']
            message.body = form.cleaned_data['body']
            message.sender = request.user
            message.recipient = manager_exists
            message.sent_at = datetime.utcnow()
            message.save()

            saved = True

    data.update({'parish': parish, 'form': form, 'saved': saved})

    return render(request, 'core/parish_message.html', data)
Пример #17
0
 def send_message(self, sender, recipient, parent=None, conversation=None):
     msg = Message(
         sender=sender,
         recipient=recipient,
         subject='Subject Text',
         body='Body Text',
         parent_msg=parent,
         conversation=conversation,
     )
     msg.save()
     return msg
Пример #18
0
 def create(self, host_class, sender, recipient, subject, body):
     from auxiliary import int_to_base36
     print 'creating ', host_class, sender, recipient, subject, body
     host_class_to_from = ','.join([int_to_base36(host_class.pk), sender.username, recipient.username])
     m, c = self.get_or_create(host_class_to_from=host_class_to_from)
     if c:
         message = Message(sender=sender,recipient=recipient,subject=subject,body=body)
         message.save()
         m.message=message
         m.save()
         print 'created', m
     return m
Пример #19
0
    def test_content_filter(self):

        body_before = """this is my phone number: 0678987890, +33687898765, 06 87 98 54 67
        this is my email: [email protected], [email protected], [email protected]"""
        msg1 = Message(sender=self.user1,
                       recipient=self.user2,
                       subject='test of content filter',
                       body=body_before)
        msg1.save()
        body_after = """this is my phone number: %(rs)s, %(rs)s, %(rs)s
        this is my email: %(rs)s, %(rs)s, %(rs)s""" % {
            'rs': settings.REPLACE_STRING
        }
        self.assertEquals(msg1.body, body_after)
Пример #20
0
 def save(self, parent_msg=None):
     # recipients = self.cleaned_data['recipient']
     recipient = self.cleaned_data['recipient']
     subject = self.cleaned_data['subject']
     body = self.cleaned_data['body']
     # for r in recipients:
     r = recipient
     if True:
         msg = Message(
             sender = self.sender,
             recipient = r,
             subject = subject,
             body = body,
         )
         if parent_msg is not None:
             msg.parent_msg = parent_msg
             parent_msg.replied_at = datetime.datetime.now()
             parent_msg.save()
             msg.conversation = parent_msg.conversation
         msg.save()
         # FIXME: workaround to make sure msg.conversation is saved
         #        even when creating a new conversation
         if not msg.conversation:
             msg.conversation = msg
             msg.save()
     return msg
Пример #21
0
class DeleteTestCase(TestCase):
    def setUp(self):
        self.user1 = User.objects.create_user(
            'user3', '*****@*****.**', '123456')
        self.user2 = User.objects.create_user(
            'user4', '*****@*****.**', '123456')
        self.msg1 = Message(sender=self.user1, recipient=self.user2,
                            subject='Subject Text 1', body='Body Text 1')
        self.msg2 = Message(sender=self.user1, recipient=self.user2,
                            subject='Subject Text 2', body='Body Text 2')
        self.msg1.sender_deleted_at = timezone.now()
        self.msg2.recipient_deleted_at = timezone.now()
        self.msg1.save()
        self.msg2.save()

    def testBasic(self):
        self.assertEqual(Message.objects.outbox_for(self.user1).count(), 1)
        self.assertEqual(
            Message.objects.outbox_for(self.user1)[0].subject,
            'Subject Text 2'
        )
        self.assertEqual(Message.objects.inbox_for(self.user2).count(), 1)
        self.assertEqual(
            Message.objects.inbox_for(self.user2)[0].subject,
            'Subject Text 1'
        )
        #undelete
        self.msg1.sender_deleted_at = None
        self.msg2.recipient_deleted_at = None
        self.msg1.save()
        self.msg2.save()
        self.assertEqual(Message.objects.outbox_for(self.user1).count(), 2)
        self.assertEqual(Message.objects.inbox_for(self.user2).count(), 2)
Пример #22
0
def inbox(request, template_name='django_messages/inbox.html'):
    """
    Displays a list of received messages for the current user.
    Optional Arguments:
        ``template_name``: name of the template to use.
    """
    message_list = Message.objects.inbox_for(request.user)
    if request.method == 'POST':
        data = request.POST
        msg = Message(body=data['body'], subject="default", sender=request.user, recipient=data['recipient'], sent_at=datetime.datetime.now())
        msg.save()
    return render_to_response(template_name, {
        'message_list': message_list,
    }, context_instance=RequestContext(request))
Пример #23
0
class DeleteTestCase(TestCase):
    def setUp(self):
        self.user1 = User.objects.create_user(
            'user3', '*****@*****.**', '123456')
        self.user2 = User.objects.create_user(
            'user4', '*****@*****.**', '123456')
        self.msg1 = Message(sender=self.user1, recipient=self.user2,
                            subject='Subject Text 1', body='Body Text 1')
        self.msg2 = Message(sender=self.user1, recipient=self.user2,
                            subject='Subject Text 2', body='Body Text 2')
        self.msg1.sender_deleted_at = timezone.now()
        self.msg2.recipient_deleted_at = timezone.now()
        self.msg1.save()
        self.msg2.save()

    def testBasic(self):
        self.assertEqual(Message.objects.outbox_for(self.user1).count(), 1)
        self.assertEqual(
            Message.objects.outbox_for(self.user1)[0].subject,
            'Subject Text 2'
        )
        self.assertEqual(Message.objects.inbox_for(self.user2).count(), 1)
        self.assertEqual(
            Message.objects.inbox_for(self.user2)[0].subject,
            'Subject Text 1'
        )
        #undelete
        self.msg1.sender_deleted_at = None
        self.msg2.recipient_deleted_at = None
        self.msg1.save()
        self.msg2.save()
        self.assertEqual(Message.objects.outbox_for(self.user1).count(), 2)
        self.assertEqual(Message.objects.inbox_for(self.user2).count(), 2)
Пример #24
0
class SendTestCase(TestCase):
    def setUp(self):
        self.user1 = User.objects.create_user('user1', '*****@*****.**', '123456')
        self.user2 = User.objects.create_user('user2', '*****@*****.**', '123456')
        self.msg1 = Message(sender=self.user1, recipient=self.user2, body='Body Text')
        self.msg1.save()
        
    def testBasic(self):
        self.assertEquals(self.msg1.sender, self.user1)
        self.assertEquals(self.msg1.recipient, self.user2)
        self.assertEquals(self.msg1.body, 'Body Text')
        self.assertEquals(self.user1.sent_messages.count(), 1)
        self.assertEquals(self.user1.received_messages.count(), 0)
        self.assertEquals(self.user2.received_messages.count(), 1)
        self.assertEquals(self.user2.sent_messages.count(), 0)
Пример #25
0
class SendTestCase(TestCase):
    def setUp(self):
        self.user1 = User.objects.create_user("user1", "*****@*****.**", "123456")
        self.user2 = User.objects.create_user("user2", "*****@*****.**", "123456")
        self.msg1 = Message(sender=self.user1, recipient=self.user2, subject="Subject Text", body="Body Text")
        self.msg1.save()

    def testBasic(self):
        self.assertEquals(self.msg1.sender, self.user1)
        self.assertEquals(self.msg1.recipient, self.user2)
        self.assertEquals(self.msg1.subject, "Subject Text")
        self.assertEquals(self.msg1.body, "Body Text")
        self.assertEquals(self.user1.sent_messages.count(), 1)
        self.assertEquals(self.user1.received_messages.count(), 0)
        self.assertEquals(self.user2.received_messages.count(), 1)
        self.assertEquals(self.user2.sent_messages.count(), 0)
Пример #26
0
class SendTestCase(TestCase):
    def setUp(self):
        self.user1 = User.objects.create_user('user1', '*****@*****.**', '123456')
        self.user2 = User.objects.create_user('user2', '*****@*****.**', '123456')
        self.msg1 = Message(sender=self.user1, recipient=self.user2, subject='Subject Text', body='Body Text')
        self.msg1.save()
        
    def testBasic(self):
        self.assertEquals(self.msg1.sender, self.user1)
        self.assertEquals(self.msg1.recipient, self.user2)
        self.assertEquals(self.msg1.subject, 'Subject Text')
        self.assertEquals(self.msg1.body, 'Body Text')
        self.assertEquals(self.user1.sent_messages.count(), 1)
        self.assertEquals(self.user1.received_messages.count(), 0)
        self.assertEquals(self.user2.received_messages.count(), 1)
        self.assertEquals(self.user2.sent_messages.count(), 0)
Пример #27
0
def view(request,
         message_id,
         template_name='dashboard/messages/view_message.html'):
    user = request.user
    now = timezone.now()
    message = get_object_or_404(Message, id=message_id)
    subject = "Re: {0}".format(message.subject)
    inbox_list = Message.objects.inbox_for(request.user)
    if (message.sender != user) and (message.recipient != user):
        raise Http404
    if message.read_at is None and message.recipient == user:
        message.read_at = now
        message.save()
    context = {
        'message': message,
        'current_page_title': 'View Message',
        'inbox_list': inbox_list
    }
    if request.method == "POST":
        sender = request.user
        form_response = request.POST.dict()
        form_response.pop('csrfmiddlewaretoken')
        Message(sender=sender,
                parent_msg=message,
                subject=subject,
                replied_at=now,
                recipient_id=message.sender.id,
                **form_response).save()
        return HttpResponseRedirect(reverse('dashboard:message_inbox'))
    return render(request, template_name, context)
Пример #28
0
    def save(self, sender, parent_msg=None):
        groupname = self.cleaned_data['recipient']
        subject = self.cleaned_data['subject']
        body = self.cleaned_data['body']
        message_list = []

        # Added by SFH - Process group messages if present
        # Group identifiers are in the form "group-offering-12345" or "group-world-3434"
        if groupname.startswith("group-"):
            grouptype = groupname.split('-')[1]
            groupid = groupname.split('-')[2]

            if grouptype == "offering":
                offering = Offering.objects.get(course_sec_id=groupid)
                recipients = [
                    profile.user for profile in offering.students.all()
                ]

        for r in recipients:
            msg = Message(
                sender=sender,
                recipient=r,
                subject=subject,
                body=body,
            )
            if parent_msg is not None:
                msg.parent_msg = parent_msg
                parent_msg.replied_at = timezone.now()
                parent_msg.save()
            msg.save()
            message_list.append(msg)
            if notification:
                if parent_msg is not None:
                    notification.send([sender], "messages_replied", {
                        'message': msg,
                    })
                    notification.send([r], "messages_reply_received", {
                        'message': msg,
                    })
                else:
                    notification.send([sender], "messages_sent", {
                        'message': msg,
                    })
                    notification.send([r], "messages_received", {
                        'message': msg,
                    })
        return message_list
Пример #29
0
 def setUp(self):
     self.user1 = User.objects.create_user(
         'user1', '*****@*****.**', '123456')
     self.user2 = User.objects.create_user(
         'user2', '*****@*****.**', '123456')
     self.msg1 = Message(sender=self.user1, recipient=self.user2,
                         subject='Subject Text', body='Body Text')
     self.msg1.save()
Пример #30
0
 def save(self, sender, parent_msg=None):
     recipients = self.cleaned_data['recipient']
     subject = self.cleaned_data['subject']
     body = self.cleaned_data['body']
     message_list = []
     for r in recipients:
         msg = Message(
             sender = sender,
             recipient = r,
             subject = subject,
             body = body,
         )
         if parent_msg is not None:
             msg.parent_msg = parent_msg
             parent_msg.replied_at = datetime.datetime.now()
             parent_msg.save()
         msg.save()
         message_list.append(msg)
     return message_list
Пример #31
0
 def save(self, sender, parent_msg=None):
     recipients = self.cleaned_data['recipient']
     subject = self.cleaned_data['subject']
     body = self.cleaned_data['body']
     message_list = []
     for r in recipients:
         msg = Message(
             sender=sender,
             recipient=r,
             subject=subject,
             body=body,
         )
         if parent_msg is not None:
             msg.parent_msg = parent_msg
             parent_msg.replied_at = datetime.datetime.now()
             parent_msg.save()
         msg.save()
         message_list.append(msg)
     return message_list
Пример #32
0
 def create_recipient_message(self, recipient, message):
     return Message(
         owner = recipient,
         sender = self.sender,
         to = recipient.username,
         recipient = recipient,
         subject = message.subject,
         body = message.body,
         thread = message.thread,
         sent_at = message.sent_at,
     )
Пример #33
0
def compose(request, recipient=None):
    template_name = 'dashboard/messages/compose_message.html'
    context = {}
    if request.method == "POST":
        sender = request.user
        form_response = request.POST.dict()
        form_response['recipient'] = HealthierUser.objects.get(
            id=form_response.get('recipient'))
        form_response.pop('csrfmiddlewaretoken')
        message_obj = Message(sender=sender, **form_response)
        message_obj.save()
        response_obj = HttpResponseRedirect(
            reverse('dashboard:message_outbox'))
        response_obj.set_cookie('status', True)
        response_obj.set_cookie('message',
                                "Your message has been successfully sent.")
        return response_obj
    context['current_page_title'] = "Message Composer"
    context['recipient'] = Consumer.objects.all(
    ) if request.user.account_type == "PRO" else Provider.objects.all()
    return render(request, template_name, context)
Пример #34
0
def comentarios(request):
		 
	perfildestino = get_object_or_404(Perfil,usuario=request.user, esActivo=True)
	comentario = Comentario.objects.filter(esChat=False).order_by('-fecha')
	print perfildestino
	list = Comentario.objects.filter(perfilDestino=perfildestino, esChat=False, esPrivado=True, estaLeido=False)
	print list
	for comentPriv in list: 
		print comentPriv
		comentPriv2=Comentario.objects.get(pk=comentPriv.id)
		print comentPriv2
		#form = ComentarioLeidoForm(request.POST.get('estaLeido'), request.FILES, instance=comentPriv)
		#print form
		#form.estaLeido=True
		#print form
		comentPriv2.estaLeido=True
		comentPriv2.save()

		mensaje = Message()#perfilDestino=user Poner destinatario.
		mensaje.subject="Comentario privado al perfil " + comentPriv.perfilDestino.alias + " ha sido leido"		
		mensaje.body="Comentario privado al perfil " + comentPriv.perfilDestino.alias + " enviado desde tu perfil " + comentPriv.perfilOrigen.alias + " ha sido leido. Texto del mensaje: " + comentPriv2.texto
		

		try:
			administrador = User.objects.get(username="******")#perfil
			mensaje.sender=administrador
			print administrador
			print request.user
		except ObjectDoesNotExist, e:
			mensaje.sender=request.user

		mensaje.recipient=comentPriv.perfilOrigen.usuario
		mensaje.sent_at=datetime.datetime.now()
		mensaje.save()	

		
		print True

		#form.save()
		print "guardado"
Пример #35
0
def votar(request, perfil_id,caract_id,valorVoto):#falta enviar la notificacion, lo del anonimo
	
	miperfil=Perfil.objects.get(usuario=request.user, esActivo=True)

	pdestino=Perfil.objects.get(pk=perfil_id)

	tipov=TipoVotacion.objects.get(pk=caract_id)


	try:
		verifica = Votacion.objects.get(perfilDestino=pdestino, perfilOrigen=miperfil, tipoVotacion = tipov)#perfil
		print "Ya has votado"
	except ObjectDoesNotExist, e:
 		
		votos=Votacion.objects.filter(perfilDestino=pdestino)
		print miperfil
		form = Votacion(perfilOrigen=miperfil,puntuacion=valorVoto) 

		if miperfil.votoAnonimo == True:
			form.esAnonima=True
		else:
			form.esAnonima=False

			mensaje = Message()#perfilDestino=user Poner destinatario.
			mensaje.subject=miperfil.alias + " te ha puntuado en " + tipov.nombre

			mensaje.body=miperfil.alias + " te ha puntuado en " + tipov.nombre + " con una puntuacion de " + valorVoto


			try:
				administrador = User.objects.get(username="******")#perfil
				mensaje.sender=administrador
				print administrador
				print request.user
			except ObjectDoesNotExist, e:
				mensaje.sender=request.user
			
			mensaje.recipient=pdestino.usuario
			mensaje.sent_at=datetime.datetime.now()
			mensaje.save()	
Пример #36
0
 def save(self, sender, parent_msg=None):
     recipients = self.cleaned_data["recipient"]
     subject = self.cleaned_data["subject"]
     body = self.cleaned_data["body"]
     message_list = []
     for r in recipients:
         msg = Message(sender=sender, recipient=r, subject=subject, body=body)
         if parent_msg is not None:
             msg.parent_msg = parent_msg
             parent_msg.replied_at = datetime.datetime.now()
             parent_msg.save()
         msg.save()
         message_list.append(msg)
         # some notification message should not send here,such as
         # 'messages_replied' and 'messages_sent'
         if notification:
             if parent_msg is not None:
                 # notification.send([sender], "messages_replied", {'message': msg,})
                 notification.send([r], "messages_reply_received", {"message": msg})
             else:
                 # notification.send([sender], "messages_sent", {'message': msg,})
                 notification.send([r], "messages_received", {"message": msg})
     return message_list
Пример #37
0
def create_message(request, usernames=[], subject="", text_body="", action="", pm_id=""):
    recipients = []
    for username in usernames:
        recipients.append(get_user(username))

    for recipient in recipients:
        msg = Message()
        msg.recipient = recipient
        msg.sender = request.user
        msg.subject = subject
        msg.body = text_body
        if action == "reply":
            msg.parent_msg_id = pm_id
        msg.save()

    return {"result": True, "msg_id": msg.id}
Пример #38
0
    def save(self, sender, parent_msg=None):
        groupname = self.cleaned_data['recipient']
        subject = self.cleaned_data['subject']
        body = self.cleaned_data['body']
        message_list = []

        # Added by SFH - Process group messages if present
        # Group identifiers are in the form "group-offering-12345" or "group-world-3434"
        if groupname.startswith("group-"):
            grouptype = groupname.split('-')[1]
            groupid = groupname.split('-')[2]

            if grouptype == "offering":
                offering = Offering.objects.get(course_sec_id=groupid)
                recipients = [profile.user for profile in offering.students.all()]

        for r in recipients:
            msg = Message(
                sender = sender,
                recipient = r,
                subject = subject,
                body = body,
            )
            if parent_msg is not None:
                msg.parent_msg = parent_msg
                parent_msg.replied_at = timezone.now()
                parent_msg.save()
            msg.save()
            message_list.append(msg)
            if notification:
                if parent_msg is not None:
                    notification.send([sender], "messages_replied", {'message': msg,})
                    notification.send([r], "messages_reply_received", {'message': msg,})
                else:
                    notification.send([sender], "messages_sent", {'message': msg,})
                    notification.send([r], "messages_received", {'message': msg,})
        return message_list
Пример #39
0
def send_reply(request, msg_body, msg_subject, msg_receiver, parent_id):
    '''
        JSON-RPC view : meow.sendMsgReply
        
        Returns True, if the currently authenticated user is successful in sending the reply message.
	
	Inbound parameters: test string 'msg_body' & 'msg_subject'. text string 'msg_receiver' shld
        be username of MEOW user, 'parent_id' shld be the msg id of an existing mesage.

	Requires authentication to call this function.
  '''

    try:
        logging.debug('start meow.sendMsgReply with %s %s %s %d ' %
                      (msg_body, msg_subject, msg_receiver, parent_id))
        msg_receiver_user = User.objects.all().filter(username=msg_receiver)
        if len(msg_receiver_user) != 1:
            return False
        msg_receiver_user = msg_receiver_user[0]
        logging.debug(" MSG %s %s %s %s  %d" %
                      (request.user, msg_receiver_user, msg_subject, msg_body,
                       parent_id))
        msg = Message(
            sender=request.user,
            recipient=msg_receiver_user,
            subject=msg_subject,
            body=msg_body,
        )
        parent_msg_obj = Message.objects.filter(id=parent_id)
        if (len(parent_msg_obj) != 1):
            return False
        msg.parent_msg = parent_msg_obj[0]
        msg.save()
        return True
    except:
        logging.error('meow.sendMsgReply got exception')
        return False
Пример #40
0
    def setUp(self):
        self.user1 = User.objects.create_user('user3', '*****@*****.**', '123456')
        self.user2 = User.objects.create_user('user4', '*****@*****.**', '123456')
        self.msg1 = Message(sender=self.user1, recipient=self.user2, subject='Subject Text 1', body='Body Text 1')
        self.msg2 = Message(sender=self.user1, recipient=self.user2, subject='Subject Text 2', body='Body Text 2')
        self.msg1.sender_deleted_at = timezone.now()
        self.msg2.recipient_deleted_at = timezone.now()
        self.msg1.save()
        self.msg2.save()

	adminrole=Role.objects.get(pk=1)
        self.user1_role=User_Roles(name="test", user_userid=self.user1, role_roleid=adminrole)
        self.user1_role.save()
        self.user2_role=User_Roles(name="test", user_userid=self.user2, role_roleid=adminrole)
        self.user2_role.save()
	mainorganisation = Organisation.objects.get(pk=1)
        user_organisation1 = User_Organisations(user_userid=self.user1, organisation_organisationid=mainorganisation)
        user_organisation1.save()
        user_organisation2 = User_Organisations(user_userid=self.user2, organisation_organisationid=mainorganisation)
        user_organisation2.save()


        print(User.objects.all())
        print(User_Roles.objects.all())
 def send_reply(self, parent_msg, body):
     message_list = []
     recipient = parent_msg.sender
     sender = parent_msg.recipient
     subject = "re: %s" % re.sub(r"^(re:\s*)+","",parent_msg.subject)
     msg = Message(
         sender = sender,
         recipient = recipient,
         subject = subject,
         body = body,
     )
     msg.parent_msg = parent_msg
     parent_msg.replied_at = datetime.datetime.now()
     parent_msg.save()
     msg.save()
     message_list.append(msg)
     if notification:
         if parent_msg is not None:
             notification.send([sender], "messages_replied", {'message': msg,})
             notification.send([recipient], "messages_reply_received", {'message': msg,}, from_address=settings.MESSAGES_HANDLER_ADDRESS)
         else:
             notification.send([sender], "messages_sent", {'message': msg,})
             notification.send([recipient], "messages_received", {'message': msg,}, from_address=settings.MESSAGES_HANDLER_ADDRESS)
     return message_list
Пример #42
0
class DeleteTestCase(TestCase):
    fixtures = ['uploadeXe/fixtures/initial-model-data.json']
    def setUp(self):
        self.user1 = User.objects.create_user('user3', '*****@*****.**', '123456')
        self.user2 = User.objects.create_user('user4', '*****@*****.**', '123456')
        self.msg1 = Message(sender=self.user1, recipient=self.user2, subject='Subject Text 1', body='Body Text 1')
        self.msg2 = Message(sender=self.user1, recipient=self.user2, subject='Subject Text 2', body='Body Text 2')
        self.msg1.sender_deleted_at = timezone.now()
        self.msg2.recipient_deleted_at = timezone.now()
        self.msg1.save()
        self.msg2.save()

	adminrole=Role.objects.get(pk=1)
        self.user1_role=User_Roles(name="test", user_userid=self.user1, role_roleid=adminrole)
        self.user1_role.save()
        self.user2_role=User_Roles(name="test", user_userid=self.user2, role_roleid=adminrole)
        self.user2_role.save()
	mainorganisation = Organisation.objects.get(pk=1)
        user_organisation1 = User_Organisations(user_userid=self.user1, organisation_organisationid=mainorganisation)
        user_organisation1.save()
        user_organisation2 = User_Organisations(user_userid=self.user2, organisation_organisationid=mainorganisation)
        user_organisation2.save()


        print(User.objects.all())
        print(User_Roles.objects.all())
                
    def testBasic(self):
        self.assertEqual(Message.objects.outbox_for(self.user1).count(), 1)
        self.assertEqual(Message.objects.outbox_for(self.user1)[0].subject, 'Subject Text 2')
        self.assertEqual(Message.objects.inbox_for(self.user2).count(),1)
        self.assertEqual(Message.objects.inbox_for(self.user2)[0].subject, 'Subject Text 1')
        #undelete
        self.msg1.sender_deleted_at = None
        self.msg2.recipient_deleted_at = None
        self.msg1.save()
        self.msg2.save()
        self.assertEqual(Message.objects.outbox_for(self.user1).count(), 2)
        self.assertEqual(Message.objects.inbox_for(self.user2).count(),2)
Пример #43
0
def create_message(request, usernames=[], subject='', text_body='', action='', pm_id=''):


    recipients = []
    for username in usernames:
        recipients.append(get_user(username))

    for recipient in recipients:
        msg = Message()
        msg.recipient = recipient
        msg.sender = request.user
        msg.subject = subject
        msg.body = text_body
        if action == 'reply':
            msg.parent_msg_id = pm_id
        msg.save()


    return {
        'result': True,
        'msg_id': msg.id,
    }
Пример #44
0
    def test_site_filter(self):

        # ok case
        msg1 = Message(sender=self.user1,
                       recipient=self.user2,
                       subject='test of site filter',
                       body="test site")
        msg1.save()
        self.assertEquals(msg1.recipient, self.user2)

        # ko case
        user_uk = Patron(username="******",
                         password="******",
                         email="*****@*****.**")
        user_uk.save()
        user_uk.sites.clear()
        msg2 = Message(sender=self.user1,
                       recipient=user_uk,
                       subject='test of site filter',
                       body="test site")
        msg2.save()
        self.assertEquals(msg2.recipient, None)
Пример #45
0
class DeleteTestCase(TestCase):
    def setUp(self):
        self.user1 = User.objects.create_user("user3", "*****@*****.**", "123456")
        self.user2 = User.objects.create_user("user4", "*****@*****.**", "123456")
        self.msg1 = Message(sender=self.user1, recipient=self.user2, subject="Subject Text 1", body="Body Text 1")
        self.msg2 = Message(sender=self.user1, recipient=self.user2, subject="Subject Text 2", body="Body Text 2")
        self.msg1.sender_deleted_at = datetime.datetime.now()
        self.msg2.recipient_deleted_at = datetime.datetime.now()
        self.msg1.save()
        self.msg2.save()

    def testBasic(self):
        self.assertEquals(Message.objects.outbox_for(self.user1).count(), 1)
        self.assertEquals(Message.objects.outbox_for(self.user1)[0].subject, "Subject Text 2")
        self.assertEquals(Message.objects.inbox_for(self.user2).count(), 1)
        self.assertEquals(Message.objects.inbox_for(self.user2)[0].subject, "Subject Text 1")
        # undelete
        self.msg1.sender_deleted_at = None
        self.msg2.recipient_deleted_at = None
        self.msg1.save()
        self.msg2.save()
        self.assertEquals(Message.objects.outbox_for(self.user1).count(), 2)
        self.assertEquals(Message.objects.inbox_for(self.user2).count(), 2)
Пример #46
0
    def save(self, sender, parent_msg=None):
        recipients = self.cleaned_data['recipient']
        subject = self.cleaned_data['subject']
        body = self.cleaned_data['body']
        message_list = []
        for r in recipients:
            msg = Message(
                sender=sender,
                recipient=r,
                subject=subject,
                body=body,
            )
            if parent_msg is not None:
                msg.parent_msg = parent_msg
                parent_msg.replied_at = timezone.now()
                parent_msg.save()
                msg.save()
                signals.message_repled.send(sender=ComposeForm, message=msg, user=sender)
            else:
                msg.save()
                signals.message_sent.send(sender=ComposeForm, message=msg, user=sender)

            message_list.append(msg)
        return message_list
Пример #47
0
def reply(request,
          message_id,
          form_class=ComposeForm,
          template_name='user/mensajes/redactar.html',
          success_url=None,
          recipient_filter=None,
          quote_helper=format_quote):
    """
    Prepares the ``form_class`` form for writing a reply to a given message
    (specified via ``message_id``). Uses the ``format_quote`` helper from
    ``messages.utils`` to pre-format the quote. To change the quote format
    assign a different ``quote_helper`` kwarg in your url-conf.
    
    """
    parent = get_object_or_404(Message, id=message_id)

    user = request.user
    now = datetime.datetime.now()
    esta_destinatario = False

    for destinatario in parent.con_copia.get_query_set():
        if destinatario.grupos == None:
            if destinatario.usuarios.user == user:
                esta_destinatario = True
                continue
        elif destinatario.usuarios == None:
            if user in destinatario.grupos.user_set.get_query_set():
                esta_destinatario = True
                continue

    for destinatario in parent.recipient.get_query_set():
        if destinatario.grupos == None:
            if destinatario.usuarios.user == user:
                esta_destinatario = True
                continue
        elif destinatario.usuarios == None:
            if user in destinatario.grupos.user_set.get_query_set():
                esta_destinatario = True
                continue

    if (parent.sender != user) and (esta_destinatario == False):
        raise Http404

    if request.method == "POST":
        sender = request.user
        form = form_class(request.POST)
        if form.is_valid():
            estado_memo = EstadoMemo.objects.get(nombre='En espera')
            mensaje = Message(
                sender=Destinatarios.objects.get(usuarios__user=request.user),
                subject=request.POST['subject'],
                body=request.POST['body'],
                status=estado_memo,
                parent_msg=parent,
            )
            mensaje.save()
            dest = []
            for i in request.POST['recipient'].split('|'):
                if not i == '':
                    dest.append(int(i))
            for destin in dest:
                sender = Destinatarios.objects.filter(id=destin)
                if sender.exists():
                    mensaje.recipient.add(sender[0])
            mensaje.save()
            mensaje_txt = u"Mensaje enviado exitosamente."

            # Guardar log de envío de memo
            LogEntry.objects.create(
                user_id=request.user.pk,
                content_type_id=ContentType.objects.get_for_model(Message).id,
                object_id=mensaje.id,
                object_repr=repr(mensaje),
                change_message=mensaje_txt,
                action_flag=ADDITION)
            mensaje = mensaje_txt

            return inbox(request, mensaje)
    else:
        cuerpo = u"\n\n%s escribió:\n%s" % (parent.sender, parent.body)
        recipient = parent.recipient.add(parent.sender)
        destins = []
        for recip in parent.recipient.get_query_set():
            destins.append(recip.id)
        form = form_class(
            initial={
                'subject': _(u"Re: %(subject)s") % {
                    'subject': parent.subject
                },
                'body': cuerpo,
                'recipient': destins
            })
    return render_to_response(template_name, {
        'tipo': 'Responder',
        'request': request,
        'form': form,
    },
                              context_instance=RequestContext(request))
Пример #48
0
 def setUp(self):
     self.user1 = User.objects.create_user("user1", "*****@*****.**", "123456")
     self.user2 = User.objects.create_user("user2", "*****@*****.**", "123456")
     self.msg1 = Message(sender=self.user1, recipient=self.user2, subject="Subject Text", body="Body Text")
     self.msg1.save()