gcivil-nyu-org / Wednesday-Fall2023-Team-4 / 638

Committed 21 Nov 2023 02:45PM UTC coverage: 79.079% (+0.8%) from 78.296%

Build # 638

Build Type

push

travis-pro

Committed by

web-flow

Commit Message

Merge pull request #191 from gcivil-nyu-org/dev-hp2427

Dev hp2427

Run Details

50 of 77 new or added lines in 4 files covered. (64.94%)

5 existing lines in 2 files now uncovered.

979 of 1238 relevant lines covered (79.08%)

0.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

79.84

/chat/views.py

from django.shortcuts import render
from django.db.models import Q
from django.views import generic

from django.http import HttpResponseRedirect
from django.urls import reverse
from django.core.exceptions import PermissionDenied

from rrapp.models import User
from .models import DirectMessage, DirectMessagePermission, Permission


def index(request):
    return render(request, 'chat/index.html')


def get_pending_connections_count(username):
    try:
        pending_connections_count = DirectMessagePermission.objects.filter(
            Q(receiver__exact=username) & Q(permission__exact=Permission.REQUESTED)
        ).count()
    except DirectMessagePermission.DoesNotExist:
        pending_connections_count = 0

    return pending_connections_count


# def conversation(request, receiverUsername):
#     senderUsername = request.user.username
#     room_name = '_'.join(sorted([senderUsername, receiverUsername]))

#     messages = DirectMessage.objects.filter(room=room_name)[0:25]

#     try:
#         permissions = list(
#             DirectMessagePermission.objects.filter(
#                 Q(sender__exact=senderUsername) | Q(receiver__exact=senderUsername)
#             )
#         )
#     except DirectMessagePermission.DoesNotExist:
#         permissions = [
#             DirectMessagePermission.objects.create(
#                 sender=senderUsername,
#                 receiver=receiverUsername,
#                 permission=Permission.ALLOWED,
#             )
#         ]

#     allowed_usernames = []
#     for p in permissions:
#         if p.sender == senderUsername:
#             allowed_usernames.append(p.receiver)
#         else:
#             allowed_usernames.append(p.sender)

#     return render(
#         request,
#         'chat/conversation.html',
#         {
#             'room_name': room_name,
#             'sender': senderUsername,
#             'receiver': receiverUsername,
#             'messages': messages,
#             'allowed_usernames': allowed_usernames,
#         },
#     )


class ConversationHomeView(generic.View):
    def dispatch(self, request, *args, **kwargs):
        # will redirect to the home page if a user tries to
        # access the register page while logged in
        if not request.user.is_authenticated:
            return HttpResponseRedirect(reverse("rrapp:login"))
        # else process dispatch as it otherwise normally would
        return super(ConversationHomeView, self).dispatch(request, *args, **kwargs)

    def get(self, request, *args, **kwargs):
        cur_username = request.user.username

        pending_connections = []
        active_connections = []
        requested_connections = []

        try:
            pending_connections = list(
                DirectMessagePermission.objects.filter(
                    Q(receiver__exact=cur_username)
                    & Q(permission__exact=Permission.REQUESTED)
                )
            )
        except DirectMessagePermission.DoesNotExist:
            pending_connections = []

        all_pending_connection_usernamesids = []
        for p in pending_connections:
            all_pending_connection_usernamesids.append(
                {
                    'id': p.sender.id,
                    'username': p.sender.username,
                }
            )

        try:
            active_connections = list(
                DirectMessagePermission.objects.filter(
                    Q(sender__exact=cur_username)
                    & Q(permission__exact=Permission.ALLOWED)
                )
            )
        except DirectMessagePermission.DoesNotExist:
            active_connections = []

        all_active_connection_usernamesids = []
        for p in active_connections:
            if p.sender.username == cur_username:
                all_active_connection_usernamesids.append(
                    {
                        'id': p.receiver.id,
                        'username': p.receiver.username,
                    }
                )
            else:
                print(p.sender, p.receiver, p.permission, cur_username)
                all_active_connection_usernamesids.append(
                    {'id': p.sender.id, 'username': p.sender.username}
                )

        try:
            requested_connections = list(
                DirectMessagePermission.objects.filter(
                    Q(sender__exact=cur_username)
                    & Q(permission__exact=Permission.REQUESTED)
                )
            )
        except DirectMessagePermission.DoesNotExist:
            requested_connections = []

        all_requested_connection_usernamesids = []
        for p in requested_connections:
            all_requested_connection_usernamesids.append(
                {
                    'id': p.receiver.id,
                    'username': p.receiver.username,
                }
            )

        try:
            blocked_connections = list(
                DirectMessagePermission.objects.filter(
                    Q(receiver__exact=cur_username)
                    & Q(permission__exact=Permission.BLOCKED)
                )
            )
        except DirectMessagePermission.DoesNotExist:
            blocked_connections = []

        all_blocked_connection_usernamesids = []
        for p in blocked_connections:
            all_blocked_connection_usernamesids.append(
                {
                    'id': p.sender.id,
                    'username': p.sender.username,
                }
            )

        return render(
            request,
            'chat/conversation_home.html',
            {
                'cur_username': cur_username,
                'pending_connections': all_pending_connection_usernamesids,
                'active_connections': all_active_connection_usernamesids,
                'requested_connections': all_requested_connection_usernamesids,
                'blocked_connections': all_blocked_connection_usernamesids,
            },
        )

    def post(self, request, *args, **kwargs):
        if "connection_accept" in request.POST:
            otherUser = User.objects.get(username=request.POST["connection_accept"])
            p = DirectMessagePermission.objects.get(
                sender=otherUser, receiver=request.user
            )
            p.permission = Permission.ALLOWED
            p.save()

            DirectMessagePermission.objects.update_or_create(
                defaults={"permission": Permission.ALLOWED},
                receiver=otherUser,
                sender=request.user,
            )
        elif "connection_reject" in request.POST:
            otherUser = User.objects.get(username=request.POST["connection_reject"])
            p = DirectMessagePermission.objects.get(
                sender=otherUser, receiver=request.user
            )
            p.delete()
        elif "connection_withdraw" in request.POST:
            otherUser = User.objects.get(username=request.POST["connection_withdraw"])
            p = DirectMessagePermission.objects.get(
                receiver=otherUser,
                sender=request.user,
            )
            p.delete()
        elif "connection_unblock" in request.POST:
            otherUser = User.objects.get(username=request.POST["connection_unblock"])
            DirectMessagePermission.objects.filter(
                sender=otherUser,
                receiver=request.user.username,
            ).update(permission=Permission.ALLOWED)
        else:
            pass

        return HttpResponseRedirect(reverse("chat:conversation_home"))


class ConversationView(generic.View):
    def dispatch(self, request, *args, **kwargs):
        # will redirect to the home page if a user tries to
        # access the register page while logged in
        if not request.user.is_authenticated:
            return HttpResponseRedirect(reverse("rrapp:login"))
        # else process dispatch as it otherwise normally would
        return super(ConversationView, self).dispatch(request, *args, **kwargs)

    def canDmReceiver(self, senderUsername, receiverUsername):
        try:
            permissions = list(
                DirectMessagePermission.objects.filter(
                    (
                        Q(sender__exact=senderUsername)
                        & Q(receiver__exact=receiverUsername)
                    )
                )
            )
        except DirectMessagePermission.DoesNotExist:
            # permission does not exist
            return False

        if len(permissions) == 0:
            return False

        p = permissions[0]
        if p.permission != Permission.ALLOWED:
            return False

        return True

    def get(self, request, receiverUsername, *args, **kwargs):
        senderUsername = request.user.username
        room_name = '_'.join(sorted([senderUsername, receiverUsername]))

        if not self.canDmReceiver(senderUsername, receiverUsername):
            print(senderUsername, receiverUsername)
            raise PermissionDenied(
                'The receiver must accept your request before your can message them.'
            )

        # TODO paginate
        messages = DirectMessage.objects.filter(room=room_name)

        # ALLOWED permission exists in DB
        # render the page and handle messages
        receiverUser = User.objects.get(username=receiverUsername)
        receiverUsernameId = {"username": receiverUsername, "id": receiverUser.id}

        try:
            recipientPermission = DirectMessagePermission.objects.get(
                sender=receiverUser, receiver=request.user
            )
        except DirectMessagePermission.DoesNotExist:
            recipientPermission = None

        return render(
            request,
            'chat/conversation_http.html',
            {
                'room_name': room_name,
                'sender': senderUsername,
                'receiver': receiverUsernameId,
                'messages': messages,
                'recipient_permission': recipientPermission,
            },
        )

    def post(self, request, *args, **kwargs):
        senderUsername = request.user.username
        receiverUsername = kwargs["receiverUsername"]
        senderUser = User.objects.get(username=senderUsername)
        receiverUser = User.objects.get(username=receiverUsername)

        if not self.canDmReceiver(senderUsername, receiverUsername):
            raise PermissionDenied(
                'The receiver needs to accept your request before your can send messages to them.'
            )

        if (
            'chat-message-input' in request.POST
            and request.POST['chat-message-input'] != ""
        ):
            room_name = '_'.join(sorted([senderUsername, receiverUsername]))
            print('saving ', request.POST)
            DirectMessage.objects.create(
                sender=senderUser,
                receiver=receiverUser,
                room=room_name,
                content=request.POST['chat-message-input'],
            )

        if 'block-user' in request.POST:
            # receiver should not be able to contact cur_user
            # print('blocking', receiverUsername, '-->', senderUsername)
            DirectMessagePermission.objects.filter(
                sender=receiverUser, receiver=senderUser
            ).update(permission=Permission.BLOCKED)
            return HttpResponseRedirect(reverse("chat:conversation_home"))

        if 'unblock-user' in request.POST:
            # receiver should be able to contact cur_user
            # print('unblocking', receiverUsername, '-->', senderUsername)
            DirectMessagePermission.objects.filter(
                sender=receiverUser, receiver=senderUser
            ).update(permission=Permission.ALLOWED)

        return HttpResponseRedirect(
            reverse("chat:conversation", kwargs={"receiverUsername": receiverUsername})
        )

1	from django.shortcuts import render	1✔
2	from django.db.models import Q	1✔
3	from django.views import generic	1✔
4
5	from django.http import HttpResponseRedirect	1✔
6	from django.urls import reverse	1✔
7	from django.core.exceptions import PermissionDenied	1✔
8
9	from rrapp.models import User	1✔
10	from .models import DirectMessage, DirectMessagePermission, Permission	1✔
11
12
13	def index(request):	1✔
14	return render(request, 'chat/index.html')	×
15
16
17	def get_pending_connections_count(username):	1✔
18	try:	1✔
19	pending_connections_count = DirectMessagePermission.objects.filter(	1✔
20	Q(receiver__exact=username) & Q(permission__exact=Permission.REQUESTED)
21	).count()
22	except DirectMessagePermission.DoesNotExist:	×
23	pending_connections_count = 0	×
24
25	return pending_connections_count	1✔
26
27
28	# def conversation(request, receiverUsername):
29	# senderUsername = request.user.username
30	# room_name = '_'.join(sorted([senderUsername, receiverUsername]))
31
32	# messages = DirectMessage.objects.filter(room=room_name)[0:25]
33
34	# try:
35	# permissions = list(
36	# DirectMessagePermission.objects.filter(
37	# Q(sender__exact=senderUsername) \| Q(receiver__exact=senderUsername)
38	# )
39	# )
40	# except DirectMessagePermission.DoesNotExist:
41	# permissions = [
42	# DirectMessagePermission.objects.create(
43	# sender=senderUsername,
44	# receiver=receiverUsername,
45	# permission=Permission.ALLOWED,
46	# )
47	# ]
48
49	# allowed_usernames = []
50	# for p in permissions:
51	# if p.sender == senderUsername:
52	# allowed_usernames.append(p.receiver)
53	# else:
54	# allowed_usernames.append(p.sender)
55
56	# return render(
57	# request,
58	# 'chat/conversation.html',
59	# {
60	# 'room_name': room_name,
61	# 'sender': senderUsername,
62	# 'receiver': receiverUsername,
63	# 'messages': messages,
64	# 'allowed_usernames': allowed_usernames,
65	# },
66	# )
67
68
69	class ConversationHomeView(generic.View):	1✔
70	def dispatch(self, request, args, *kwargs):	1✔
71	# will redirect to the home page if a user tries to
72	# access the register page while logged in
73	if not request.user.is_authenticated:	1✔
74	return HttpResponseRedirect(reverse("rrapp:login"))	1✔
75	# else process dispatch as it otherwise normally would
76	return super(ConversationHomeView, self).dispatch(request, args, *kwargs)	1✔
77
78	def get(self, request, args, *kwargs):	1✔
79	cur_username = request.user.username	1✔
80
81	pending_connections = []	1✔
82	active_connections = []	1✔
83	requested_connections = []	1✔
84
85	try:	1✔
86	pending_connections = list(	1✔
87	DirectMessagePermission.objects.filter(
88	Q(receiver__exact=cur_username)
89	& Q(permission__exact=Permission.REQUESTED)
90	)
91	)
92	except DirectMessagePermission.DoesNotExist:	×
93	pending_connections = []	×
94
95	all_pending_connection_usernamesids = []	1✔
96	for p in pending_connections:	1✔
97	all_pending_connection_usernamesids.append(	1✔
98	{
99	'id': p.sender.id,
100	'username': p.sender.username,
101	}
102	)
103
104	try:	1✔
105	active_connections = list(	1✔
106	DirectMessagePermission.objects.filter(
107	Q(sender__exact=cur_username)
108	& Q(permission__exact=Permission.ALLOWED)
109	)
110	)
111	except DirectMessagePermission.DoesNotExist:	×
112	active_connections = []	×
113
114	all_active_connection_usernamesids = []	1✔
115	for p in active_connections:	1✔
NEW 116	if p.sender.username == cur_username:	×
117	all_active_connection_usernamesids.append(	×
118	{
119	'id': p.receiver.id,
120	'username': p.receiver.username,
121	}
122	)
123	else:
NEW 124	print(p.sender, p.receiver, p.permission, cur_username)	×
UNCOV 125	all_active_connection_usernamesids.append(	×
126	{'id': p.sender.id, 'username': p.sender.username}
127	)
128
129	try:	1✔
130	requested_connections = list(	1✔
131	DirectMessagePermission.objects.filter(
132	Q(sender__exact=cur_username)
133	& Q(permission__exact=Permission.REQUESTED)
134	)
135	)
136	except DirectMessagePermission.DoesNotExist:	×
137	requested_connections = []	×
138
139	all_requested_connection_usernamesids = []	1✔
140	for p in requested_connections:	1✔
141	all_requested_connection_usernamesids.append(	1✔
142	{
143	'id': p.receiver.id,
144	'username': p.receiver.username,
145	}
146	)
147
148	try:	1✔
149	blocked_connections = list(	1✔
150	DirectMessagePermission.objects.filter(
151	Q(receiver__exact=cur_username)
152	& Q(permission__exact=Permission.BLOCKED)
153	)
154	)
155	except DirectMessagePermission.DoesNotExist:	×
156	blocked_connections = []	×
157
158	all_blocked_connection_usernamesids = []	1✔
159	for p in blocked_connections:	1✔
160	all_blocked_connection_usernamesids.append(	×
161	{
162	'id': p.sender.id,
163	'username': p.sender.username,
164	}
165	)
166
167	return render(	1✔
168	request,
169	'chat/conversation_home.html',
170	{
171	'cur_username': cur_username,
172	'pending_connections': all_pending_connection_usernamesids,
173	'active_connections': all_active_connection_usernamesids,
174	'requested_connections': all_requested_connection_usernamesids,
175	'blocked_connections': all_blocked_connection_usernamesids,
176	},
177	)
178
179	def post(self, request, args, *kwargs):	1✔
180	if "connection_accept" in request.POST:	1✔
181	otherUser = User.objects.get(username=request.POST["connection_accept"])	1✔
182	p = DirectMessagePermission.objects.get(	1✔
183	sender=otherUser, receiver=request.user
184	)
185	p.permission = Permission.ALLOWED	1✔
186	p.save()	1✔
187
188	DirectMessagePermission.objects.update_or_create(	1✔
189	defaults={"permission": Permission.ALLOWED},
190	receiver=otherUser,
191	sender=request.user,
192	)
193	elif "connection_reject" in request.POST:	1✔
194	otherUser = User.objects.get(username=request.POST["connection_reject"])	1✔
195	p = DirectMessagePermission.objects.get(	1✔
196	sender=otherUser, receiver=request.user
197	)
198	p.delete()	1✔
199	elif "connection_withdraw" in request.POST:	1✔
200	otherUser = User.objects.get(username=request.POST["connection_withdraw"])	1✔
201	p = DirectMessagePermission.objects.get(	1✔
202	receiver=otherUser,
203	sender=request.user,
204	)
205	p.delete()	1✔
206	elif "connection_unblock" in request.POST:	1✔
207	otherUser = User.objects.get(username=request.POST["connection_unblock"])	1✔
208	DirectMessagePermission.objects.filter(	1✔
209	sender=otherUser,
210	receiver=request.user.username,
211	).update(permission=Permission.ALLOWED)
212	else:
213	pass
214
215	return HttpResponseRedirect(reverse("chat:conversation_home"))	1✔
216
217
218	class ConversationView(generic.View):	1✔
219	def dispatch(self, request, args, *kwargs):	1✔
220	# will redirect to the home page if a user tries to
221	# access the register page while logged in
222	if not request.user.is_authenticated:	1✔
223	return HttpResponseRedirect(reverse("rrapp:login"))	1✔
224	# else process dispatch as it otherwise normally would
225	return super(ConversationView, self).dispatch(request, args, *kwargs)	1✔
226
227	def canDmReceiver(self, senderUsername, receiverUsername):	1✔
228	try:	1✔
229	permissions = list(	1✔
230	DirectMessagePermission.objects.filter(
231	(
232	Q(sender__exact=senderUsername)
233	& Q(receiver__exact=receiverUsername)
234	)
235	)
236	)
237	except DirectMessagePermission.DoesNotExist:	×
238	# permission does not exist
239	return False	×
240
241	if len(permissions) == 0:	1✔
242	return False	×
243
244	p = permissions[0]	1✔
245	if p.permission != Permission.ALLOWED:	1✔
246	return False	×
247
248	return True	1✔
249
250	def get(self, request, receiverUsername, args, *kwargs):	1✔
251	senderUsername = request.user.username	1✔
252	room_name = '_'.join(sorted([senderUsername, receiverUsername]))	1✔
253
254	if not self.canDmReceiver(senderUsername, receiverUsername):	1✔
255	print(senderUsername, receiverUsername)	×
256	raise PermissionDenied(	×
257	'The receiver must accept your request before your can message them.'
258	)
259
260	# TODO paginate
261	messages = DirectMessage.objects.filter(room=room_name)	1✔
262
263	# ALLOWED permission exists in DB
264	# render the page and handle messages
265	receiverUser = User.objects.get(username=receiverUsername)	1✔
266	receiverUsernameId = {"username": receiverUsername, "id": receiverUser.id}	1✔
267
268	try:	1✔
269	recipientPermission = DirectMessagePermission.objects.get(	1✔
270	sender=receiverUser, receiver=request.user
271	)
272	except DirectMessagePermission.DoesNotExist:	×
273	recipientPermission = None	×
274
275	return render(	1✔
276	request,
277	'chat/conversation_http.html',
278	{
279	'room_name': room_name,
280	'sender': senderUsername,
281	'receiver': receiverUsernameId,
282	'messages': messages,
283	'recipient_permission': recipientPermission,
284	},
285	)
286
287	def post(self, request, args, *kwargs):	1✔
288	senderUsername = request.user.username	1✔
289	receiverUsername = kwargs["receiverUsername"]	1✔
290	senderUser = User.objects.get(username=senderUsername)	1✔
291	receiverUser = User.objects.get(username=receiverUsername)	1✔
292
293	if not self.canDmReceiver(senderUsername, receiverUsername):	1✔
294	raise PermissionDenied(	×
295	'The receiver needs to accept your request before your can send messages to them.'
296	)
297
298	if (	1✔
299	'chat-message-input' in request.POST
300	and request.POST['chat-message-input'] != ""
301	):
302	room_name = '_'.join(sorted([senderUsername, receiverUsername]))	1✔
303	print('saving ', request.POST)	1✔
304	DirectMessage.objects.create(	1✔
305	sender=senderUser,
306	receiver=receiverUser,
307	room=room_name,
308	content=request.POST['chat-message-input'],
309	)
310
311	if 'block-user' in request.POST:	1✔
312	# receiver should not be able to contact cur_user
313	# print('blocking', receiverUsername, '-->', senderUsername)
314	DirectMessagePermission.objects.filter(	1✔
315	sender=receiverUser, receiver=senderUser
316	).update(permission=Permission.BLOCKED)
317	return HttpResponseRedirect(reverse("chat:conversation_home"))	1✔
318
319	if 'unblock-user' in request.POST:	1✔
320	# receiver should be able to contact cur_user
321	# print('unblocking', receiverUsername, '-->', senderUsername)
322	DirectMessagePermission.objects.filter(	1✔
323	sender=receiverUser, receiver=senderUser
324	).update(permission=Permission.ALLOWED)
325
326	return HttpResponseRedirect(	1✔
327	reverse("chat:conversation", kwargs={"receiverUsername": receiverUsername})
328	)

gcivil-nyu-org / Wednesday-Fall2023-Team-4 / 638

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous