Ejemplo n.º 1
0
    def post(self, request, *args, **kwargs):
        from users.models import User
        from chat.models import Message
        from common.check.user import check_user_can_get_list
        from chat.forms import MessageForm
        from django.http import HttpResponse

        self.form, self.user, connections = MessageForm(
            request.POST), User.objects.get(
                pk=self.kwargs["pk"]), request.POST.getlist("chat_items")
        check_user_can_get_list(request.user, self.user)

        if request.is_ajax() and self.form.is_valid():
            message = self.form.save(commit=False)
            if request.POST.get('text') or request.POST.get(
                    'attach_items') or request.POST.get('sticker'):
                _message = Message.get_or_create_chat_and_send_message(
                    creator=request.user,
                    user=self.user,
                    text=message.text,
                    voice=request.POST.get('voice'),
                    attach=request.POST.getlist('attach_items'),
                    sticker=request.POST.get('sticker'))
                return HttpResponse()
            else:
                from django.http import HttpResponseBadRequest
                return HttpResponseBadRequest()
Ejemplo n.º 2
0
def add_message(request, chat_id):
	form = MessageForm
	error = {}

	try:
		chat = Chat.objects.get(id=chat_id)
	except Chat.DoesNotExist:
		raise Http404

	if request.method == "POST":
		form = MessageForm(request.POST)

		if form.is_valid():
			f = form.save(commit=False)
			f.ip = "1.2.3.4"
			f.chat = chat


			f.save()

			if request.is_ajax():
				error['error'] = 'False'
				return HttpResponse(simplejson.dumps(error))
			else:
				return redirect('/messages/%s/' % (f.chat.id))
Ejemplo n.º 3
0
def authenticated_chat(request, model_key, owner_id):
    """
    View for chat which is "read only" for unauthenticated and "writeable" for authenticated users.
    Requires **page** as **GET** parameter for page number. Last page will be used for default.

    owner_id: id of the owner model.
    model_key: one of the **KEY_KEY_TO_CHAT_OWNER** keys.
    """
    ModelClass = KEY_TO_CHAT_OWNER[model_key]
    owner = get_object_or_404(ModelClass.objects, id=owner_id)
    if not owner.chat:
        raise Http404()
    if request.method == 'POST':
        if not request.user.is_authenticated():
            return HttpResponseForbidden()
        form = MessageForm(request.POST, request.user, owner.chat)
        if form.is_valid():
            form.save()
            return redirect('authenticated_chat', model_key=model_key, owner_id=owner.id)
    else:
        form = MessageForm()
    owner.chat.url = reverse('authenticated_chat', kwargs={
        'owner_id': owner_id,
        'model_key': model_key,
    })
    owner.chat.rss = reverse('open_rss', kwargs={
        'id': owner_id,
        'model_key': model_key,
    })
    return render(request, 'parts/chat_message_list.html', {
        'form': form,
        'chat': owner.chat,
        'page': get_chat_page(owner.chat, request.GET.get('page')),
    })
Ejemplo n.º 4
0
def sendMessage(request, participationID=None):
    # send message and redirect to the conversation
    form = MessageForm(request.POST)
    if form.is_valid():
        messagetext = form.cleaned_data['message']

        subject = 'Test email when new message is sent'
        message = 'This is the message content, if you read this the test has worked! Daijoubu!'
        from_email = settings.EMAIL_HOST_USER
        to_list = [settings.EMAIL_HOST_USER]

        send_mail(subject, message, from_email, to_list, fail_silently=False)

        if participationID:
            participation = ConversationParticipation.objects.get(
                pk=participationID)
            if request.user == participation.user:
                Message(conversation=participation.conversation,
                        content=messagetext,
                        sender=request.user).save()
        return redirect('chat:detail',
                        participationID=participationID,
                        conversationname=slugify(
                            participation.get_conversation_name())
                        )  # TODO participation is niet altijd geinitialisseerd
    def test_message_form_valid_data(self):
        """ Test form is valid with correct data """

        form = MessageForm({
            'message': 'A test message',
        })

        self.assertTrue(form.is_valid())
Ejemplo n.º 6
0
def create_message(request, chat_id=None):
    chat = get_object_or_404(Chat, id=chat_id)
    form = MessageForm(user=request.user, chat=chat, data=request.POST)
    if form.is_valid():
        msg = form.save()
        return HttpResponseAjax(**msg.to_dict)
    else:
        return HttpResponseAjaxError(errors=form.errors)
Ejemplo n.º 7
0
 def post(self, request, pk):
     form = MessageForm(data=request.POST)
     if form.is_valid():
         message = form.save(commit=False)
         message.chat_id = pk
         message.author = self.request.user
         message.save()
         #new_message.delay(message.id, message.author, message.chat_id)
     return redirect(reverse('messages', kwargs={'pk': pk}))
Ejemplo n.º 8
0
def send_message(request, user_id):
    if request.method == 'POST':
        form = MessageForm(request.POST)
        message = form.save(commit=False)
        message.sender = request.user
        receiver = User.objects.get(id=user_id)
        message.receiver = receiver
        message.save()
        return HttpResponseRedirect(reverse("chat:chat_room"))
Ejemplo n.º 9
0
    def post(self, request, message_id, *args, **kwargs):
        message = Message.objects.get(id=message_id, author=request.user)
        form = MessageForm(request.POST)

        if form.is_valid():
            message.message = form.cleaned_data.get('message')
            message.changed = True
            message.save()

        return redirect('chat', pk=message.chat_id)
    def test_message_form_invalid_with_no_data(self):
        """ Test form is invalid with missing data
            Test form displays correct error message
        """

        form = MessageForm({
            'message': '',
        })

        self.assertFalse(form.is_valid())
        self.assertEqual(form.errors['message'], ['This field is required.'])
Ejemplo n.º 11
0
 def post(self, request, pk):
     chat = get_object_or_404(Chat, id=pk)
     if request.user in chat.members.all():
         form = MessageForm(data=request.POST)
         if form.is_valid():
             message = form.save(commit=False)
             message.chat_id = pk
             message.author = self.request.user
             message.save()
             new_message.apply_async(args=[
                 message.id,
             ], countdown=3600)
         return redirect(reverse('messages', kwargs={'pk': pk}))
Ejemplo n.º 12
0
class UserSendPageMessage(TemplateView):
    """ Пишем сообщения со страниц пользователей или разных списков. Если у пользователя есть друзья,
	    то add_friend_message.html (возможность добавлять друзей), иначе add_message.html
	"""
    template_name = None

    def get(self, request, *args, **kwargs):
        from users.models import User
        from common.templates import get_my_template

        self.template_name = get_my_template("chat/message/add_message.html",
                                             request.user,
                                             request.META['HTTP_USER_AGENT'])
        self.user = User.objects.get(pk=self.kwargs["pk"])
        return super(UserSendPageMessage, self).get(request, *args, **kwargs)

    def get_context_data(self, **kwargs):
        from chat.forms import MessageForm

        context = super(UserSendPageMessage, self).get_context_data(**kwargs)
        context["form"] = MessageForm()
        context["member"] = self.user
        return context

    def post(self, request, *args, **kwargs):
        from users.models import User
        from chat.models import Message
        from common.check.user import check_user_can_get_list
        from chat.forms import MessageForm
        from django.http import HttpResponse

        self.form, self.user, connections = MessageForm(
            request.POST), User.objects.get(
                pk=self.kwargs["pk"]), request.POST.getlist("chat_items")
        check_user_can_get_list(request.user, self.user)

        if request.is_ajax() and self.form.is_valid():
            message = self.form.save(commit=False)
            if request.POST.get('text') or request.POST.get(
                    'attach_items') or request.POST.get('sticker'):
                _message = Message.get_or_create_chat_and_send_message(
                    creator=request.user,
                    user=self.user,
                    text=message.text,
                    voice=request.POST.get('voice'),
                    attach=request.POST.getlist('attach_items'),
                    sticker=request.POST.get('sticker'))
                return HttpResponse()
            else:
                from django.http import HttpResponseBadRequest
                return HttpResponseBadRequest()
Ejemplo n.º 13
0
    def get_context_data(self, **kwargs):
        from chat.forms import MessageForm

        context = super(UserMessageEdit, self).get_context_data(**kwargs)
        context["object"] = self.message
        context["form"] = MessageForm(instance=self.message)
        return context
Ejemplo n.º 14
0
    def post(self, request, *args, **kwargs):
        from chat.models import Message, Chat
        from chat.forms import MessageForm

        chat, form_post = Chat.objects.get(pk=self.kwargs["pk"]), MessageForm(
            request.POST, request.FILES)
        if request.POST.get('text') or request.POST.get(
                'attach_items') or request.POST.get(
                    'sticker') or request.POST.get('transfer'):
            message = form_post.save(commit=False)

            new_message = Message.send_message(
                chat=chat,
                creator=request.user,
                repost=None,
                text=message.text,
                sticker=request.POST.get('sticker'),
                parent=request.POST.get('parent'),
                transfer=request.POST.getlist('transfer'),
                attach=request.POST.getlist('attach_items'))
            from common.templates import render_for_platform
            return render_for_platform(request, 'chat/message/message.html',
                                       {'object': new_message})

        from django.http import HttpResponseBadRequest
        return HttpResponseBadRequest()
Ejemplo n.º 15
0
def home(request):
    request.user  # On récupère les infos du user connecté
    last_messages = Message.objects.order_by('-date')  # On récupère tous les messages
    if request.method == "POST":  # Si le formulaire a été envoyé
        form = MessageForm(request.POST)  # On récupère le formulaire choisi
        if form.is_valid():
            pseudo = request.user.username  # On récupère le pseudo du user connecté
            msg = request.POST.get('message', '')  # On récupère le message du formulaire
            message = Message.objects.create(user=pseudo, content=msg)  # On insère en base
            if message:  # Si l'objet renvoyé n'est pas None
                last_messages = Message.objects.order_by('-date')
            else:  # Sinon une erreur sera affichée
                error = True
    else:
        form = MessageForm()  # On affiche le formulaire choisi
    return render(request, 'index.html', locals())
Ejemplo n.º 16
0
    def get_context_data(self, **kwargs):
        from chat.forms import MessageForm

        context = super(UserSendPageMessage, self).get_context_data(**kwargs)
        context["form"] = MessageForm()
        context["member"] = self.user
        return context
Ejemplo n.º 17
0
def view_tournament(request, tournament_id):
    tournament = get_object_or_404(Tournament.objects, id=tournament_id)
    default_competition_start = int(
        max(to_timestamp(tournament.first_datetime),
            to_timestamp(datetime.now())))
    is_event_owner = is_owner(tournament, request.user)
    context = {
        'tournament': tournament,
        'is_owner': is_event_owner,
        'default_competition_start': default_competition_start,
        'chat_form': MessageForm(),
    }
    if request.user.is_authenticated():
        template_name = 'authenticated_tournament.html'
        if not is_event_owner:
            managed_tags = Tag.objects.filter(
                id__in=get_managed_tag_ids(request.user))
            context.update({
                'can_add_tags':
                managed_tags.exclude(
                    id__in=tournament.tags.values_list('id', flat=True)),
                'managed_tags':
                managed_tags,
            })
    else:
        template_name = 'unauthenticated_tournament.html'
    return render(request, template_name, context)
Ejemplo n.º 18
0
def view_team(request, team):
    return render(
        request, 'view_team.html', {
            'team': team,
            'is_owner': is_in_share_tree(request.user, team.owner),
            'chat_form': MessageForm(),
            'page_number': request.GET.get('page'),
        })
Ejemplo n.º 19
0
    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['form'] = MessageForm()

        messages = Message.objects.filter(
            room=context['object']).order_by('-datetime')[:50]
        context['messages'] = messages[::-1]

        return context
Ejemplo n.º 20
0
    def post(self, request, *args, **kwargs):
        from chat.forms import MessageForm

        form = MessageForm(request.POST, request.FILES)

        if request.is_ajax() and form.is_valid(
        ) and request.user.is_administrator():
            from chat.models import Message

            form_post = form.save(commit=False)
            Message.get_or_create_manager_chat_and_send_message(
                creator_pk=request.user.pk,
                text=form_post.text,
                voice=request.POST.get('voice'),
                attach=request.POST.getlist('attach_items'))
            return HttpResponse()
        else:
            return HttpResponseBadRequest()
Ejemplo n.º 21
0
def team_chat(request, team):
    if request.method == 'POST':
        form = MessageForm(request.POST, request.user, team.chat)
        if form.is_valid():
            form.save()
            return redirect('team_chat', team_id=team.id)
    else:
        form = MessageForm()
    page = get_chat_page(team.chat, request.REQUEST.get('page'))
    team.chat.url = reverse('team_chat', kwargs={'team_id': team.id})
    team_rss = TeamChatFeed()
    team.owner_key = request.user.userprofile.external_read_auth
    team.chat.rss = team_rss.link(team)
    return render(request, 'parts/chat_message_list.html', {
        'chat': team.chat,
        'form': form,
        'page': page,
    })
Ejemplo n.º 22
0
def newMessage(request, userID=None, projectID=None):
    # if projectID is none, a new message to a user is requested
    user = request.user
    if userID:
        anonymous = False
        otherUser = get_object_or_404(User, pk=userID)
    # if userID is none, a conversation about a project is requested where the project owner is anonymous
    else:
        anonymous = True
        otherUser = get_object_or_404(Project, pk=projectID).owner

    if request.method == "POST":  # a message is been send
        form = MessageForm(request.POST)
        if form.is_valid():
            messagetext = form.cleaned_data['message']
            participation = get_or_create_participation(
                user, otherUser, anonymous, projectID)
            Message.objects.create(conversation=participation.conversation,
                                   content=messagetext,
                                   sender=user)
            return redirect('chat:detail',
                            participationID=participation.id,
                            conversationname=slugify(
                                participation.get_conversation_name()))

    else:  # the page is loaded, ready to send a new message
        # if the conversation already exists, move to that conversation
        if conversation_exists(user, otherUser, anonymous):
            participation = get_or_create_participation(
                user, otherUser, anonymous)
            return redirect('chat:detail',
                            participationID=participation.id,
                            conversationname=slugify(
                                participation.get_conversation_name()))
        else:  # otherwise, prepare to receive a new message
            context = {
                'messageForm': MessageForm(),
            }
            if userID:
                context['otherUser'] = get_object_or_404(User, pk=userID)
            else:
                context['project'] = get_object_or_404(Project, pk=projectID)

            return render(request, "chat/new_message.html", context)
Ejemplo n.º 23
0
def detail(request, event_id):
    event = get_object_or_404(Event, pk=event_id)

    if request.method == 'POST' and request.user in event.participants.all():
        form = MessageForm(request.POST)

        if form.is_valid():
            new_message = form.save(commit=False)
            new_message.chat = event.chat
            new_message.chat.last_activity = timezone.now()
            new_message.author = request.user

            new_message.chat.save()
            new_message.save()

            return redirect('events:detail', event_id=event_id)

    else:
        form = MessageForm()

    storage = messages.get_messages(request)

    context = {'event': event, 'messages': storage, 'form': form}

    return render(request, 'events/detail.html', context)
def MaintRequestDetail(request, id):
    """
    Display detail view of particular maintenance request.
    Allow for landlord to assign cost to tenant/landlord
    """

    # get relevant maintenance request
    maint_request = get_object_or_404(MaintRequest, id=id)

    # get chat messages
    chat_messages = ChatMessage.objects.filter(maint_request=maint_request)  

    # check current user rental is the property relevant to the maintenance request
    if request.user.profile.rental == maint_request.property_ref:

        # message form instance for message section
        message_form = MessageForm()

        if request.method == 'POST':

            # the landlord can update the cost of the maintenance request
            if 'cost' in request.POST:
                assign_cost_form = MaintenanceQuoteForm(request.POST, request.FILES, instance=maint_request)
                if assign_cost_form.is_valid():
                    assign_cost_form.save()
                    messages.success(request, 'Cost of work updated')
                    return redirect('maint-detail', id=id)

            # the landlord can update the status of the request
            elif 'status' in request.POST:
                status_form = StatusUpdateForm(request.POST, instance=maint_request)
                if status_form.is_valid():
                    status_form.save()
                    messages.success(request, 'Status of request updated')
                    return redirect('maint-detail', id=id)

        assign_cost_form = MaintenanceQuoteForm(instance=maint_request)
        status_form = StatusUpdateForm(instance=maint_request)

        context = {
            'maint_request': maint_request,
            'chat_messages': chat_messages,
            'message_form': message_form,
            'assign_cost_form': assign_cost_form,
            'status_form': status_form,
        }

        return render(request, 'maintenance/maint_detail.html', context)

    else:
        # if current user rental does not match related property
        raise PermissionDenied()
Ejemplo n.º 25
0
    def get(self, request, *args, **kwargs):
        self.object = self.get_object()
        form = MessageForm()

        chat_user = get_object_or_404(User, pk=kwargs["user_pk"])
        non_chat_users = User.objects.exclude(
            id__in=self.object.users.all().values_list('id', flat=True))

        context = self.get_context_data(object=self.object,
                                        form=form,
                                        chat_user=chat_user,
                                        non_chat_users=non_chat_users)
        return self.render_to_response(context)
Ejemplo n.º 26
0
    def on_message(self, message):
        self.log('User message: {0}'.format(message))
        data = {}
        data['message'] = urllib.unquote(message['message'].encode('utf-8')).decode("utf-8")

        form = MessageForm(data)

        if form.is_valid():
            object = form.save(commit=False)
            object.sender_id = message['sender']
            object.channel_id = message['channel']
            object.save()
            message.clear()
            message['room'] = self._get_room_name(object.channel_id)
            message['action'] = 'new_message'
            message['result'] = render_to_string('chat/msg_detail.html',
                                                 {'msg': object})
            # parse url
            match = re.search(r'http://[a-zA-Z0-9]+\.[-a-zA-Z0-9_]+/*', object.message)
            if match:
                try:
                    url = metadata_parser.MetadataParser(url=object.message)
                    meta = url.metadata.get('meta')
                    page = url.metadata.get('page')
                    img = meta.get('og:image', None)
                    title =  urllib.unquote(page['title'].encode('utf-8')).decode("utf-8")
                    message['result'] = render_to_string('chat/url_parse.html',
                                                        {'img': img,
                                                         'title':title,
                                                         'obj': object})
                except:
                    pass

        else:
            message.clear()
            message['action'] = 'error'

        self.emit_to_room_with_me(object.channel_id, 'message', message)
        return True
Ejemplo n.º 27
0
def chat_form(request, user_id):
    if request.is_ajax():
        queryset = User.objects.filter(id=user_id)
        if queryset.exists():
            user = queryset.first()
            form = MessageForm()
            html = render_to_string("chat-form.html", {
                "user": user,
                "form": form
            },
                                    request=request)
            return HttpResponse(html)
    else:
        return HttpResponseRedirect(reverse("chat:user_list"))
Ejemplo n.º 28
0
    def post(self, request, *args, **kwargs):
        from chat.models import Message, Chat
        from chat.forms import MessageForm
        from django.http import HttpResponse

        chat, form_post = Chat.objects.get(pk=self.kwargs["pk"]), MessageForm(
            request.POST)
        message = form_post.save(commit=False)
        Message.save_draft_message(
            chat=chat,
            creator=request.user,
            text=message.text,
            parent=request.POST.get('parent'),
            attach=request.POST.getlist('attach_items'),
            transfer=request.POST.getlist('transfer'),
        )
        return HttpResponse()
Ejemplo n.º 29
0
def MaintRequestDetail(request, id):
    """
    If user has current rental assigned to their profile.
    Display detail view of particular maintenance request.
    Allow for landlord to assign cost to tenant/landlord
    """
    maint_request = get_object_or_404(MaintRequest, id=id)
    chat_messages = ChatMessage.objects.filter(
        maint_request=maint_request)  # get chat messages

    if request.user.profile.rental == maint_request.property_ref:
        message_form = MessageForm()
        if request.method == 'POST':
            if 'cost' in request.POST:
                assign_cost_form = MaintenanceQuoteForm(request.POST,
                                                        request.FILES,
                                                        instance=maint_request)
                if assign_cost_form.is_valid():
                    assign_cost_form.save()
                    messages.success(request, 'Cost of work updated')
                    return redirect('maint-detail', id=id)

            elif 'status' in request.POST:
                status_form = StatusUpdateForm(request.POST,
                                               instance=maint_request)
                if status_form.is_valid():
                    status_form.save()
                    messages.success(request, 'Status of request updated')
                    return redirect('maint-detail', id=id)

        assign_cost_form = MaintenanceQuoteForm(instance=maint_request)
        status_form = StatusUpdateForm(instance=maint_request)

        context = {
            'maint_request': maint_request,
            'chat_messages': chat_messages,
            'message_form': message_form,
            'assign_cost_form': assign_cost_form,
            'status_form': status_form,
        }

        return render(request, 'maintenance/maint_detail.html', context)
    else:
        raise PermissionDenied()
Ejemplo n.º 30
0
 def get(self, request, pk):
     chat = get_object_or_404(Chat, id=pk)
     if request.user in chat.members.all():
         chat.messages.filter(is_read=False).exclude(
             author=request.user).update(is_read=True)
         chat_messages = chat.messages.all()
         paginator = Paginator(chat_messages,
                               settings.PAGE_SIZE_MESSAGE,
                               orphans=settings.PAGE_SIZE_MESSAGE)
         page = request.GET.get('page', paginator.num_pages)
         chat_messages = paginator.get_page(page)
         return render(request,
                       'chat.html',
                       context={
                           'user': request.user,
                           'chat': chat,
                           'chat_messages': chat_messages,
                           'form': MessageForm()
                       })
Ejemplo n.º 31
0
def team_chat(request, team):
    if request.method == 'POST':
        form = MessageForm(request.POST, request.user, team.chat)
        if form.is_valid():
            form.save()
            return redirect('team_chat', team_id=team.id)
    else:
        form = MessageForm()
    page = get_chat_page(team.chat, request.REQUEST.get('page'))
    team.chat.url = reverse('team_chat', kwargs={'team_id': team.id})
    team_rss = TeamChatFeed()
    team.owner_key = request.user.userprofile.external_read_auth
    team.chat.rss = team_rss.link(team)
    return render(request, 'parts/chat_message_list.html', {
        'chat': team.chat,
        'form': form,
        'page': page,
    })
Ejemplo n.º 32
0
def index(request):
    """
    'Calendar' page. Processes both authenticated and none-authenticated requests.
    """
    if 'force-login' in request.GET and request.flavour == 'mobile' and not request.user.is_authenticated(
    ):
        return render(request, 'login.html')
    tags_provider = get_tags_provider(request)
    tags = tags_provider.get_tags()
    popular_tags, other_tags = tags_provider.get_other_tags()
    return render(
        request, 'index.html', {
            'tags': tags,
            'popular_tags': popular_tags,
            'other_tags': other_tags,
            'show_login': '******' in request.GET,
            'base_tag': settings.BASE_TAG
            and Tag.objects.get(id=settings.BASE_TAG),
            'chat_form': MessageForm(),
        })
Ejemplo n.º 33
0
def chat(request, pk):
    ride = get_object_or_404(Ride, pk=pk)
    if request.user.pk != ride.initiator.pk and request.user.pk != ride.driver.pk:
        return redirect('profile_summary')
    if request.method == "POST":
        form = MessageForm(request.POST)
        if form.is_valid():
            message = form.save(commit=False)
            message.ride = ride
            message.user = request.user
            message.save()
            return redirect('chat', pk=ride.pk)
    else:
        form = MessageForm()
    return render(request, 'chat.html', {'form': form, 'ride': ride})
Ejemplo n.º 34
0
def user_messages_view(request, conv=None):
    if not request.user.is_authenticated:
        return redirect('login')

    if conv is None:
        return redirect('conversations')

    user = request.user
    conversation = user.profile.conversations.filter(name=conv)[0]
    form = MessageForm()
    if request.method == "POST":
        message = request.POST['message']
        new_message = MessageModel(conversation=conversation, message=message)
        new_message.save()
        user.profile.messages.add(new_message)

    return render(
        request, 'accounts/user_messages.html', {
            'profile_photo': request.user.profile.image,
            'conversation': conversation,
            "message_form": form,
        })