Python Message.author方法代码示例

# 需要导入模块: from models import Message [as 别名]
# 或者: from models.Message import author [as 别名]
def messaging_compose(request, response_format='html'):
    "New message page"

    user = request.user.profile

    if request.POST:
        if 'cancel' not in request.POST:
            message = Message()
            message.author = user.get_contact()
            if not message.author:
                return user_denied(request,
                                   message="You can't send message without a Contact Card assigned to you.",
                                   response_format=response_format)

            form = MessageForm(
                request.user.profile, None, None, request.POST, instance=message)
            if form.is_valid():
                message = form.save()
                message.recipients.add(user.get_contact())
                message.set_user_from_request(request)
                message.read_by.add(user)
                try:
                    # if email entered create contact and add to recipients
                    if 'multicomplete_recipients' in request.POST and request.POST['multicomplete_recipients']:
                        try:
                            conf = ModuleSetting.get_for_module(
                                'anaf.messaging', 'default_contact_type')[0]
                            default_contact_type = ContactType.objects.get(
                                pk=long(conf.value))
                        except Exception:
                            default_contact_type = None
                        emails = request.POST[
                            'multicomplete_recipients'].split(',')
                        for email in emails:
                            emailstr = unicode(email).strip()
                            if re.match('[a-zA-Z0-9+_\-\.][email protected][0-9a-zA-Z][.-0-9a-zA-Z]*.[a-zA-Z]+', emailstr):
                                contact, created = Contact.get_or_create_by_email(
                                    emailstr, contact_type=default_contact_type)
                                message.recipients.add(contact)
                                if created:
                                    contact.set_user_from_request(request)
                except:
                    pass
                # send email to all recipients
                message.send_email()

                return HttpResponseRedirect(reverse('messaging'))
        else:
            return HttpResponseRedirect(reverse('messaging'))

    else:
        form = MessageForm(request.user.profile, None)

    context = _get_default_context(request)
    context.update({'form': form})

    return render_to_response('messaging/message_compose', context,
                              context_instance=RequestContext(request), response_format=response_format)

# 需要导入模块: from models import Message [as 别名]
# 或者: from models.Message import author [as 别名]
	def post(self):
		# Set up the message instance
		message = Message()
		
		message.author = users.get_current_user()
		
		if self.request.get('content') != '':
			message.content = self.request.get('content')
			message.put()
	  
		self.redirect('/')

# 需要导入模块: from models import Message [as 别名]
# 或者: from models.Message import author [as 别名]
    def on_message(self, message):
        message = Message(**json.loads(message))
        message.author = self.current_user
        message.created_at = datetime.utcnow()
        message.conversation = self.conversation

        self.db.add(message)
        self.db.commit()

        for user in self.conversation.connected_users:
            user.write_message(json.dumps(message.as_json()))

# 需要导入模块: from models import Message [as 别名]
# 或者: from models.Message import author [as 别名]
    def post(self):
        message = Message()
        
        user = users.get_current_user()
        if user:
            message.author = user

        #Added the content to the message: 
       	message.content = cgi.escape(self.request.get('content'))
        #Assigned the id to the message:
        message.postID = Message.max_id() + 1
	
        message.put()

# 需要导入模块: from models import Message [as 别名]
# 或者: from models.Message import author [as 别名]
    def post(self):
        post_id = self.request.get('post_id')
        commit = self.request.get('commit')
        user = User.get_by_id(self.session['user'].email)
        assert user

        post = Post.get_by_id(post_id)
        msg = Message()
        msg.author = user
        msg.commit = commit
        
        msg.put()
        post.msgs.append(msg)
        post.put()

# 需要导入模块: from models import Message [as 别名]
# 或者: from models.Message import author [as 别名]
def mlist_view(request, mlist_id, response_format='html'):
    "Mailing List view page"

    user = request.user.profile

    mlist = get_object_or_404(MailingList, pk=mlist_id)
    if not request.user.profile.has_permission(mlist):
        return user_denied(request, message="You don't have access to this Mailing List",
                           response_format=response_format)

    if request.user.profile.has_permission(mlist, mode='x'):
        if request.POST:
            message = Message()
            message.author = request.user.profile.get_contact()
            if not message.author:
                return user_denied(request,
                                   message="You can't send message without a Contact Card assigned to you.",
                                   response_format=response_format)
            form = MessageForm(
                request.user.profile, mlist_id, None, request.POST, instance=message)
            if form.is_valid():
                message = form.save()
                message.set_user_from_request(request)
                message.read_by.add(user)
                return HttpResponseRedirect(reverse('messaging_mlist_view', args=[mlist.id]))
        else:
            form = MessageForm(request.user.profile, mlist_id)

    else:
        form = None

    messages = Object.filter_by_request(request,
                                        Message.objects.filter(reply_to__isnull=True,
                                                               mlist=mlist).order_by('-date_created'))
    context = _get_default_context(request)
    context.update({'messages': messages,
                    'form': form,
                    'mlist': mlist})

    return render_to_response('messaging/mlist_view', context,
                              context_instance=RequestContext(request),
                              response_format=response_format)

# 需要导入模块: from models import Message [as 别名]
# 或者: from models.Message import author [as 别名]
def messaging_view(request, message_id, response_format='html'):
    "Single message page"

    message = get_object_or_404(Message, pk=message_id)
    user = request.user.profile

    if not user.has_permission(message):
        return user_denied(request, message="You don't have access to this Message",
                           response_format=response_format)

    message.read_by.add(user)

    if request.POST and request.POST.get('body', False):
        "Unread message"

        reply = Message()
        reply.author = user.get_contact()
        if not reply.author:
            return user_denied(request,
                               message="You can't send message without a Contact Card assigned to you.",
                               response_format=response_format)
        reply.reply_to = message
        form = MessageReplyForm(
            user, message.stream_id, message, request.POST, instance=reply)
        if form.is_valid():
            reply = form.save()
            reply.set_user_from_request(request)
            # Add author to recipients
            reply.recipients.add(reply.author)
            message.read_by.clear()

            try:
                # if email entered create contact and add to recipients
                if 'multicomplete_recipients' in request.POST and request.POST['multicomplete_recipients']:
                    try:
                        conf = ModuleSetting.get_for_module(
                            'anaf.messaging', 'default_contact_type')[0]
                        default_contact_type = ContactType.objects.get(
                            pk=long(conf.value))
                    except Exception:
                        default_contact_type = None
                    emails = request.POST[
                        'multicomplete_recipients'].split(',')
                    for email in emails:
                        emailstr = unicode(email).strip()
                        if re.match('[a-zA-Z0-9+_\-\.][email protected][0-9a-zA-Z][.-0-9a-zA-Z]*.[a-zA-Z]+', emailstr):
                            contact, created = Contact.get_or_create_by_email(
                                emailstr, contact_type=default_contact_type)
                            reply.recipients.add(contact)
                            if created:
                                contact.set_user_from_request(request)
            except:
                pass

            # Add each recipient of the reply to the original message
            for recipient in reply.recipients.all():
                message.recipients.add(recipient)

            # send email to all recipients
            reply.send_email()

            return HttpResponseRedirect(reverse('messaging_message_view', args=[message.id]))

    else:
        form = MessageReplyForm(
            request.user.profile, message.stream_id, message)

    replies = Object.filter_by_request(request,
                                       Message.objects.filter(reply_to=message).order_by('date_created'))

    context = _get_default_context(request)
    context.update({'message': message,
                    'messages': replies,
                    'form': form})

    return render_to_response('messaging/message_view', context,
                              context_instance=RequestContext(request),
                              response_format=response_format)

# 需要导入模块: from models import Message [as 别名]
# 或者: from models.Message import author [as 别名]
def stream_view(request, stream_id, response_format='html'):
    "Stream view page"

    user = request.user.profile

    stream = get_object_or_404(MessageStream, pk=stream_id)
    if not request.user.profile.has_permission(stream):
        return user_denied(request, message="You don't have access to this Stream",
                           response_format=response_format)

    if request.user.profile.has_permission(stream, mode='x'):
        if request.POST:
            message = Message()
            message.author = user.get_contact()
            if not message.author:
                return user_denied(request,
                                   message="You can't send message without a Contact Card assigned to you.",
                                   response_format=response_format)

            form = MessageForm(
                request.user.profile, None, None, request.POST, instance=message)
            if form.is_valid():
                message = form.save()
                message.recipients.add(user.get_contact())
                message.set_user_from_request(request)
                message.read_by.add(user)
                try:
                    # if email entered create contact and add to recipients
                    if 'multicomplete_recipients' in request.POST and request.POST['multicomplete_recipients']:
                        try:
                            conf = ModuleSetting.get_for_module(
                                'anaf.messaging', 'default_contact_type')[0]
                            default_contact_type = ContactType.objects.get(
                                pk=long(conf.value))
                        except Exception:
                            default_contact_type = None
                        emails = request.POST[
                            'multicomplete_recipients'].split(',')
                        for email in emails:
                            emailstr = unicode(email).strip()
                            if re.match('[a-zA-Z0-9+_\-\.][email protected][0-9a-zA-Z][.-0-9a-zA-Z]*.[a-zA-Z]+', emailstr):
                                contact, created = Contact.get_or_create_by_email(
                                    emailstr, contact_type=default_contact_type)
                                message.recipients.add(contact)
                                if created:
                                    contact.set_user_from_request(request)
                except:
                    pass
                # send email to all recipients
                message.send_email()

                return HttpResponseRedirect(reverse('messaging_stream_view', args=[stream.id]))
        else:
            form = MessageForm(request.user.profile, stream_id)

    else:
        form = None

    objects = Object.filter_by_request(request, Message.objects.filter(
        reply_to__isnull=True, stream=stream).order_by('-date_created'))
    context = _get_default_context(request)
    context.update({'messages': objects,
                    'form': form,
                    'stream': stream})

    return render_to_response('messaging/stream_view', context,
                              context_instance=RequestContext(request),
                              response_format=response_format)